From 5e2a7881337e008a7de79914646ebe3b4fcd993e Mon Sep 17 00:00:00 2001 From: Iain McGinniss Date: Wed, 17 Oct 2012 22:18:13 +0100 Subject: [PATCH 001/826] preface and lexical syntax chapter converted, other chapters split into their own files --- .gitignore | 1 + 01-title.md | 14 + 02-preface.md | 50 + 03-lexical-syntax.md | 607 +++++++ 04-identifiers-names-and-scopes.md | 98 ++ 05-types.md | 1014 ++++++++++++ 06-basic-declarations-and-definitions.md | 935 +++++++++++ 07-classes-and-objects.md | 1222 ++++++++++++++ 08-expressions.md | 1876 ++++++++++++++++++++++ 09-implicit-parameters-and-views.md | 419 +++++ 10-pattern-matching.md | 846 ++++++++++ 11-top-level-definitions.md | 177 ++ 12-xml-expressions-and-patterns.md | 144 ++ 13-user-defined-annotations.md | 174 ++ 14-the-scala-standard-library.md | 932 +++++++++++ 15-scala-syntax-summary.md | 2 + README.md | 94 ++ Scala.bib | 193 +++ build.sh | 42 + resources/blueprint-print.css | 29 + resources/blueprint-screen.css | 265 +++ resources/grid.png | Bin 0 -> 104 bytes resources/ie.css | 36 + resources/scala-ref-template.html5 | 69 + resources/style.css | 28 + 25 files changed, 9267 insertions(+) create mode 100644 .gitignore create mode 100644 01-title.md create mode 100644 02-preface.md create mode 100644 03-lexical-syntax.md create mode 100644 04-identifiers-names-and-scopes.md create mode 100644 05-types.md create mode 100644 06-basic-declarations-and-definitions.md create mode 100644 07-classes-and-objects.md create mode 100644 08-expressions.md create mode 100644 09-implicit-parameters-and-views.md create mode 100644 10-pattern-matching.md create mode 100644 11-top-level-definitions.md create mode 100644 12-xml-expressions-and-patterns.md create mode 100644 13-user-defined-annotations.md create mode 100644 14-the-scala-standard-library.md create mode 100644 15-scala-syntax-summary.md create mode 100644 README.md create mode 100644 Scala.bib create mode 100755 build.sh create mode 100755 resources/blueprint-print.css create mode 100755 resources/blueprint-screen.css create mode 100755 resources/grid.png create mode 100755 resources/ie.css create mode 100644 resources/scala-ref-template.html5 create mode 100644 resources/style.css diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000000..378eac25d311 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +build diff --git a/01-title.md b/01-title.md new file mode 100644 index 000000000000..3e7d8e681e0a --- /dev/null +++ b/01-title.md @@ -0,0 +1,14 @@ +% The Scala Language Specification, Version 2.9 +% Martin Odersky; + Philippe Altherr; + Vincent Cremet; + Gilles Dubochet; + Burak Emir; + Philipp Haller; + Stéphane Micheloud; + Nikolay Mihaylov; + Michel Schinz; + Erik Stenman; + Matthias Zenger +% 24th May 2011 + diff --git a/02-preface.md b/02-preface.md new file mode 100644 index 000000000000..11f14d2076c9 --- /dev/null +++ b/02-preface.md @@ -0,0 +1,50 @@ +Preface +------- + +Scala is a Java-like programming language which unifies +object-oriented and functional programming. It is a pure +object-oriented language in the sense that every value is an +object. Types and behavior of objects are described by +classes. Classes can be composed using mixin composition. Scala is +designed to work seamlessly with two less pure but mainstream +object-oriented languages -- Java and C#. + +Scala is a functional language in the sense that every function is a +value. Nesting of function definitions and higher-order functions are +naturally supported. Scala also supports a general notion of pattern +matching which can model the algebraic types used in many functional +languages. + +Scala has been designed to interoperate seamlessly with Java (an +alternative implementation of Scala also works for .NET). Scala +classes can call Java methods, create Java objects, inherit from Java +classes and implement Java interfaces. None of this requires interface +definitions or glue code. + +Scala has been developed from 2001 in the programming methods +laboratory at EPFL. Version 1.0 was released in November 2003. This +document describes the second version of the language, which was +released in March 2006. It acts a reference for the language +definition and some core library modules. It is not intended to teach +Scala or its concepts; for this there are other documents +[@scala-overview-tech-report; +@odersky:scala-experiment; +@odersky:sca; +@odersky-et-al:ecoop03; +@odersky-zenger:fool12] + +Scala has been a collective effort of many people. The design and the +implementation of version 1.0 was completed by Philippe Altherr, +Vincent Cremet, Gilles Dubochet, Burak Emir, Stéphane Micheloud, +Nikolay Mihaylov, Michel Schinz, Erik Stenman, Matthias Zenger, and +the author. Iulian Dragos, Gilles Dubochet, Philipp Haller, Sean +McDirmid, Lex Spoon, and Geoffrey Washburn joined in the effort to +develop the second version of the language and tools. Gilad Bracha, +Craig Chambers, Erik Ernst, Matthias Felleisen, Shriram Krishnamurti, +Gary Leavens, Sebastian Maneth, Erik Meijer, Klaus Ostermann, Didier +Rémy, Mads Torgersen, and Philip Wadler have shaped the design of +the language through lively and inspiring discussions and comments on +previous versions of this document. The contributors to the Scala +mailing list have also given very useful feedback that helped us +improve the language and its tools. + diff --git a/03-lexical-syntax.md b/03-lexical-syntax.md new file mode 100644 index 000000000000..6153b3876443 --- /dev/null +++ b/03-lexical-syntax.md @@ -0,0 +1,607 @@ +Lexical Syntax +============== + +Scala programs are written using the Unicode Basic Multilingual Plane +(_BMP_) character set; Unicode supplementary characters are not +presently supported. This chapter defines the two modes of Scala's +lexical syntax, the Scala mode and the _XML_ mode. If not +otherwise mentioned, the following descriptions of Scala tokens refer +to Scala mode, and literal characters ‘c’ refer to the ASCII fragment +\\u0000-\\u007F + +In Scala mode, \textit{Unicode escapes} are replaced by the corresponding +Unicode character with the given hexadecimal code. + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +UnicodeEscape ::= \{\\}u{u} hexDigit hexDigit hexDigit hexDigit +hexDigit ::= ‘0’ | … | ‘9’ | ‘A’ | … | ‘F’ | ‘a’ | … | ‘f’ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +To construct tokens, characters are distinguished according to the following +classes (Unicode general category given in parentheses): + +#. Whitespace characters. `\u0020 | \u0009 | \u000D | \u000A`{.grammar} +#. Letters, which include lower case letters(Ll), upper case letters(Lu), + titlecase letters(Lt), other letters(Lo), letter numerals(Nl) and the + two characters \\u0024 ‘$’ and \\u005F ‘_’, which both count as upper case + letters +#. Digits ` ‘0’ | … | ‘9’ `{.grammar} +#. Parentheses ` ‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’ `{.grammar} +#. Delimiter characters `` ‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’ ``{.grammar} +#. Operator characters. These consist of all printable ASCII characters + \\u0020-\\u007F which are in none of the sets above, mathematical symbols(Sm) + and other symbols(So). + + +Identifiers +----------- + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +op ::= opchar {opchar} +varid ::= lower idrest +plainid ::= upper idrest + | varid + | op +id ::= plainid + | ‘\`’ stringLit ‘\`’ +idrest ::= {letter | digit} [‘_’ op] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +There are three ways to form an identifier. First, an identifier can +start with a letter which can be followed by an arbitrary sequence of +letters and digits. This may be followed by underscore ‘_’ +characters and another string composed of either letters and digits or +of operator characters. Second, an identifier can start with an operator +character followed by an arbitrary sequence of operator characters. +The preceding two forms are called _plain_ identifiers. Finally, +an identifier may also be formed by an arbitrary string between +back-quotes (host systems may impose some restrictions on which +strings are legal for identifiers). The identifier then is composed +of all characters excluding the backquotes themselves. + +As usual, a longest match rule applies. For instance, the string + +~~~~~~~~~~~~~~~~ {.scala} +big_bob++=`def` +~~~~~~~~~~~~~~~~ + +decomposes into the three identifiers `big_bob`, `++=`, and +`def`. The rules for pattern matching further distinguish between +_variable identifiers_, which start with a lower case letter, and +_constant identifiers_, which do not. + +The ‘$’ character is reserved +for compiler-synthesized identifiers. User programs should not define +identifiers which contain ‘$’ characters. + +The following names are reserved words instead of being members of the +syntactic class `id` of lexical identifiers. + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +abstract case catch class def +do else extends false final +finally for forSome if implicit +import lazy match new null +object override package private protected +return sealed super this throw +trait try true type val +var while with yield +_ : = => <- <: <% >: # @ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The Unicode operators \\u21D2 ‘⇒’ and \\u2190 ‘←’, which have the ASCII +equivalents ‘=>’ and ‘<-’, are also reserved. + +(@) Here are examples of identifiers: + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + x Object maxIndex p2p empty_? + + `yield` αρετη _y dot_product_* + __system _MAX_LEN_ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +(@) Backquote-enclosed strings are a solution when one needs to +access Java identifiers that are reserved words in Scala. For +instance, the statement `Thread.yield()` is illegal, since +`yield` is a reserved word in Scala. However, here's a +work-around: `` Thread.`yield`() ``{.scala} + + +Newline Characters +------------------ + +~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +semi ::= ‘;’ | nl {nl} +~~~~~~~~~~~~~~~~~~~~~~~~ + +Scala is a line-oriented language where statements may be terminated by +semi-colons or newlines. A newline in a Scala source text is treated +as the special token “nl” if the three following criteria are satisfied: + +#. The token immediately preceding the newline can terminate a statement. +#. The token immediately following the newline can begin a statement. +#. The token appears in a region where newlines are enabled. + +The tokens that can terminate a statement are: literals, identifiers +and the following delimiters and reserved words: + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +this null true false return type +_ ) ] } +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The tokens that can begin a statement are all Scala tokens _except_ +the following delimiters and reserved words: + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +catch else extends finally forSome match +with yield , . ; : = => <- <: <% +>: # [ ) ] } +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +A `case`{.scala} token can begin a statement only if followed by a +`class`{.scala} or `object`{.scala} token. + +Newlines are enabled in: + +#. all of a Scala source file, except for nested regions where newlines + are disabled, and +#. the interval between matching `{` and `}` brace tokens, + except for nested regions where newlines are disabled. + +Newlines are disabled in: + +#. the interval between matching `(` and `)` parenthesis tokens, except for + nested regions where newlines are enabled, and +#. the interval between matching `[` and `]` bracket tokens, except for nested + regions where newlines are enabled. +#. The interval between a `case`{.scala} token and its matching + `=>`{.scala} token, except for nested regions where newlines are + enabled. +#. Any regions analyzed in [XML mode](#xml-mode). + +Note that the brace characters of `{...}` escapes in XML and +string literals are not tokens, +and therefore do not enclose a region where newlines +are enabled. + +Normally, only a single `nl` token is inserted between two +consecutive non-newline tokens which are on different lines, even if there are multiple lines +between the two tokens. However, if two tokens are separated by at +least one completely blank line (i.e a line which contains no +printable characters), then two `nl` tokens are inserted. + +The Scala grammar (given in full [here](#scala-syntax-summary)) +contains productions where optional `nl` tokens, but not +semicolons, are accepted. This has the effect that a newline in one of these +positions does not terminate an expression or statement. These positions can +be summarized as follows: + +Multiple newline tokens are accepted in the following places (note +that a semicolon in place of the newline would be illegal in every one +of these cases): + +- between the condition of an + conditional expression ([here](#conditional-expressions)) + or while loop ([here](#while-loop-expressions)) and the next + following expression, +- between the enumerators of a + for-comprehension ([here](#for-comprehensions-and-for-loops)) + and the next following expression, and +- after the initial `type`{.scala} keyword in a type definition or + declaration ([here](#type-declarations-and-type-aliases)). + +A single new line token is accepted + +- in front of an opening brace ‘{’, if that brace is a legal + continuation of the current statement or expression, +- after an infix operator, if the first token on the next line can + start an expression ([here](#prefix-infix-and-postfix-operations)), +- in front of a parameter clause + ([here](#function-declarations-and-definitions)), and +- after an annotation ([here](#user-defined-annotations)). + +(@) The following code contains four well-formed statements, each +on two lines. The newline tokens between the two lines are not +treated as statement separators. + +~~~~~~~~~~~~~~~~~~~~~~ {.scala} +if (x > 0) + x = x - 1 + +while (x > 0) + x = x / 2 + +for (x <- 1 to 10) + println(x) + +type + IntList = List[Int] +~~~~~~~~~~~~~~~~~~~~~~ + +(@) The following code designates an anonymous class: + +~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} +new Iterator[Int] +{ + private var x = 0 + def hasNext = true + def next = { x += 1; x } +} +~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +With an additional newline character, the same code is interpreted as +an object creation followed by a local block: + +~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} +new Iterator[Int] + +{ + private var x = 0 + def hasNext = true + def next = { x += 1; x } +} +~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +(@) The following code designates a single expression: + +~~~~~~~~~~~~ {.scala} + x < 0 || + x > 10 +~~~~~~~~~~~~ + +With an additional newline character, the same code is interpreted as +two expressions: + +~~~~~~~~~~~ {.scala} + x < 0 || + + x > 10 +~~~~~~~~~~~ + +(@) The following code designates a single, curried function definition: + +~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} +def func(x: Int) + (y: Int) = x + y +~~~~~~~~~~~~~~~~~~~~~~~~~ + +With an additional newline character, the same code is interpreted as +an abstract function definition and a syntactically illegal statement: + +~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} +def func(x: Int) + + (y: Int) = x + y +~~~~~~~~~~~~~~~~~~~~~~~~~ + +(@) The following code designates an attributed definition: + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} +@serializable +protected class Data { ... } +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +With an additional newline character, the same code is interpreted as +an attribute and a separate statement (which is syntactically +illegal). + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} +@serializable + +protected class Data { ... } +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + +Literals +---------- + +\label{sec:literals} + +There are literals for integer numbers, floating point numbers, +characters, booleans, symbols, strings. The syntax of these literals is in +each case as in Java. + + + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +Literal ::= [‘-’] integerLiteral + | [‘-’] floatingPointLiteral + | booleanLiteral + | characterLiteral + | stringLiteral + | symbolLiteral + | ‘null’ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + +### Integer Literals + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +integerLiteral ::= (decimalNumeral | hexNumeral | octalNumeral) [‘L’ | ‘l’] +decimalNumeral ::= ‘0’ | nonZeroDigit {digit} +hexNumeral ::= ‘0’ ‘x’ hexDigit {hexDigit} +octalNumeral ::= ‘0’ octalDigit {octalDigit} +digit ::= ‘0’ | nonZeroDigit +nonZeroDigit ::= ‘1’ | $\cdots$ | ‘9’ +octalDigit ::= ‘0’ | $\cdots$ | ‘7’ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Integer literals are usually of type `Int`{.scala}, or of type +`Long`{.scala} when followed by a `L` or +`l` suffix. Values of type `Int`{.scala} are all integer +numbers between $-2^{31}$ and $2^{31}-1$, inclusive. Values of +type `Long`{.scala} are all integer numbers between $-2^{63}$ and +$2^{63}-1$, inclusive. A compile-time error occurs if an integer literal +denotes a number outside these ranges. + +However, if the expected type [_pt_](#expression-typing) of a literal +in an expression is either `Byte`{.scala}, `Short`{.scala}, or `Char`{.scala} +and the integer number fits in the numeric range defined by the type, +then the number is converted to type _pt_ and the literal's type +is _pt_. The numeric ranges given by these types are: + +--------------- ----------------------- +`Byte`{.scala} $-2^7$ to $2^7-1$ +`Short`{.scala} $-2^{15}$ to $2^{15}-1$ +`Char`{.scala} $0$ to $2^{16}-1$ +--------------- ----------------------- + +(@) Here are some integer literals: + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +0 21 0xFFFFFFFF 0777L +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + +### Floating Point Literals + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +floatingPointLiteral ::= digit {digit} ‘.’ {digit} [exponentPart] [floatType] + | ‘.’ digit {digit} [exponentPart] [floatType] + | digit {digit} exponentPart [floatType] + | digit {digit} [exponentPart] floatType +exponentPart ::= (‘E’ | ‘e’) [‘+’ | ‘-’] digit {digit} +floatType ::= ‘F’ | ‘f’ | ‘D’ | ‘d’ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Floating point literals are of type `Float`{.scala} when followed by +a floating point type suffix `F` or `f`, and are +of type `Double`{.scala} otherwise. The type `Float`{.scala} +consists of all IEEE 754 32-bit single-precision binary floating point +values, whereas the type `Double`{.scala} consists of all IEEE 754 +64-bit double-precision binary floating point values. + +If a floating point literal in a program is followed by a token +starting with a letter, there must be at least one intervening +whitespace character between the two tokens. + +(@) Here are some floating point literals: + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +0.0 1e30f 3.14159f 1.0e-100 .1 +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +(@) The phrase `1.toString`{.scala} parses as three different tokens: +`1`{.scala}, `.`{.scala}, and `toString`{.scala}. On the +other hand, if a space is inserted after the period, the phrase +`1. toString`{.scala} parses as the floating point literal +`1.`{.scala} followed by the identifier `toString`{.scala}. + + +### Boolean Literals + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +booleanLiteral ::= ‘true’ | ‘false’ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The boolean literals `true`{.scala} and `false`{.scala} are +members of type `Boolean`{.scala}. + + +### Character Literals + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +characterLiteral ::= ‘'’ printableChar ‘'’ + | ‘'’ charEscapeSeq ‘'’ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} + +A character literal is a single character enclosed in quotes. +The character is either a printable unicode character or is described +by an [escape sequence](#escape-sequences). + +(@) Here are some character literals: + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +'a' '\u0041' '\n' '\t' +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Note that `'\u000A'` is _not_ a valid character literal because +Unicode conversion is done before literal parsing and the Unicode +character \\u000A (line feed) is not a printable +character. One can use instead the escape sequence `'\n'` or +the octal escape `'\12'` ([see here](#escape-sequences)). + + +### String Literals + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +stringLiteral ::= ‘\"’ {stringElement} ‘\"’ +stringElement ::= printableCharNoDoubleQuote | charEscapeSeq +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +A string literal is a sequence of characters in double quotes. The +characters are either printable unicode character or are described by +[escape sequences](#escape-sequences). If the string literal +contains a double quote character, it must be escaped, +i.e. `"\""`. The value of a string literal is an instance of +class `String`{.scala}. + +(@) Here are some string literals: +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} +"Hello,\nWorld!" +"This string contains a \" character." +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +#### Multi-Line String Literals + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +stringLiteral ::= ‘"""’ multiLineChars ‘"""’ +multiLineChars ::= {[‘"’] [‘"’] charNoDoubleQuote} {‘"’} +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +A multi-line string literal is a sequence of characters enclosed in +triple quotes `""" ... """`{.scala}. The sequence of characters is +arbitrary, except that it may contain three or more consuctive quote characters +only at the very end. Characters +must not necessarily be printable; newlines or other +control characters are also permitted. Unicode escapes work as everywhere else, but none +of the escape sequences [here](#escape-sequences) are interpreted. + +(@) Here is a multi-line string literal: + +~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + """the present string + spans three + lines.""" +~~~~~~~~~~~~~~~~~~~~~~~~ + +This would produce the string: + +~~~~~~~~~~~~~~~~~~~ +the present string + spans three + lines. +~~~~~~~~~~~~~~~~~~~ + +The Scala library contains a utility method `stripMargin` +which can be used to strip leading whitespace from multi-line strings. +The expression + +~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + """the present string + |spans three + |lines.""".stripMargin +~~~~~~~~~~~~~~~~~~~~~~~~~~ + +evaluates to + +~~~~~~~~~~~~~~~~~~~~ {.scala} +the present string +spans three +lines. +~~~~~~~~~~~~~~~~~~~~ + +Method `stripMargin` is defined in class +[scala.collection.immutable.StringLike](http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.StringLike). +Because there is a predefined +[implicit conversion](#implicit-conversions) from `String`{.scala} to +`StringLike`{.scala}, the method is applicable to all strings. + + +### Escape Sequences + +The following escape sequences are recognized in character and string +literals. + +------ ------------------------------ +`\b` `\u0008`: backspace BS +`\t` `\u0009`: horizontal tab HT +`\n` `\u000a`: linefeed LF +`\f` `\u000c`: form feed FF +`\r` `\u000d`: carriage return CR +`\"` `\u0022`: double quote " +`\'` `\u0027`: single quote ' +`\\` `\u005c`: backslash `\` +------ ------------------------------- + +A character with Unicode between 0 and 255 may also be represented by +an octal escape, i.e. a backslash ‘\’ followed by a +sequence of up to three octal characters. + +It is a compile time error if a backslash character in a character or +string literal does not start a valid escape sequence. + + +### Symbol literals + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +symbolLiteral ::= ‘'’ plainid +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +A symbol literal `'x`{.scala} is a shorthand for the expression +`scala.Symbol("x")`{.scala}. `Symbol` is a [case class](#case-classes), +which is defined as follows. + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} +package scala +final case class Symbol private (name: String) { + override def toString: String = "'" + name +} +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The `apply`{.scala} method of `Symbol`{.scala}'s companion object +caches weak references to `Symbol`{.scala}s, thus ensuring that +identical symbol literals are equivalent with respect to reference +equality. + + +Whitespace and Comments +----------------------- + +Tokens may be separated by whitespace characters +and/or comments. Comments come in two forms: + +A single-line comment is a sequence of characters which starts with +`//` and extends to the end of the line. + +A multi-line comment is a sequence of characters between +`/*` and `*/`. Multi-line comments may be nested, +but are required to be properly nested. Therefore, a comment like +`/* /* */` will be rejected as having an unterminated +comment. + + +XML mode +-------- + +In order to allow literal inclusion of XML fragments, lexical analysis +switches from Scala mode to XML mode when encountering an opening +angle bracket '<' in the following circumstance: The '<' must be +preceded either by whitespace, an opening parenthesis or an opening +brace and immediately followed by a character starting an XML name. + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} + ( whitespace | ‘(’ | ‘{’ ) ‘<’ (XNameStart | ‘!’ | ‘?’) + + XNameStart ::= ‘_’ | BaseChar | Ideographic $\mbox{\rm\em (as in W3C XML, but without }$ ‘:’ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The scanner switches from XML mode to Scala mode if either + +- the XML expression or the XML pattern started by the initial ‘<’ has been + successfully parsed, or if +- the parser encounters an embedded Scala expression or pattern and + forces the Scanner + back to normal mode, until the Scala expression or pattern is + successfully parsed. In this case, since code and XML fragments can be + nested, the parser has to maintain a stack that reflects the nesting + of XML and Scala expressions adequately. + +Note that no Scala tokens are constructed in XML mode, and that comments are interpreted +as text. + +(@) The following value definition uses an XML literal with two embedded +Scala expressions + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} +val b = + The Scala Language Specification + {scalaBook.version} + {scalaBook.authors.mkList("", ", ", "")} + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + diff --git a/04-identifiers-names-and-scopes.md b/04-identifiers-names-and-scopes.md new file mode 100644 index 000000000000..2d0ba8b65ff2 --- /dev/null +++ b/04-identifiers-names-and-scopes.md @@ -0,0 +1,98 @@ +Identifiers, Names and Scopes +============================= + +Names in Scala identify types, values, methods, and classes which are +collectively called {\em entities}. Names are introduced by local +definitions and declarations (\sref{sec:defs}), inheritance (\sref{sec:members}), +import clauses (\sref{sec:import}), or package clauses +(\sref{sec:packagings}) which are collectively called {\em +bindings}. + +Bindings of different kinds have a precedence defined on them: +\begin{enumerate} +\item Definitions and declarations that are local, inherited, or made +available by a package clause in the same compilation unit where the +definition occurs have highest precedence. +\item Explicit imports have next highest precedence. +\item Wildcard imports have next highest precedence. +\item Definitions made available by a package clause not in the +compilation unit where the definition occurs have lowest precedence. +\end{enumerate} + +There are two different name spaces, one for types (\sref{sec:types}) +and one for terms (\sref{sec:exprs}). The same name may designate a +type and a term, depending on the context where the name is used. + +A binding has a {\em scope} in which the entity defined by a single +name can be accessed using a simple name. Scopes are nested. A binding +in some inner scope {\em shadows} bindings of lower precedence in the +same scope as well as bindings of the same or lower precedence in outer +scopes. + +Note that shadowing is only a partial order. In a situation like +\begin{lstlisting} +val x = 1; +{ import p.x; + x } +\end{lstlisting} +neither binding of \code{x} shadows the other. Consequently, the +reference to \code{x} in the third line above would be ambiguous. + +A reference to an unqualified (type- or term-) identifier $x$ is bound +by the unique binding, which +\begin{itemize} +\item defines an entity with name $x$ in the same namespace as the +identifier, and +\item shadows all other bindings that define entities with name $x$ in that namespace. +\end{itemize} +It is an error if no such binding exists. If $x$ is bound by an +import clause, then the simple name $x$ is taken to be equivalent to +the qualified name to which $x$ is mapped by the import clause. If $x$ +is bound by a definition or declaration, then $x$ refers to the entity +introduced by that binding. In that case, the type of $x$ is the type +of the referenced entity. + +\example Assume the following two definitions of a objects named \lstinline@X@ in packages \lstinline@P@ and \lstinline@Q@. +%ref: shadowing.scala +\begin{lstlisting} +package P { + object X { val x = 1; val y = 2 } +} +\end{lstlisting} +\begin{lstlisting} +package Q { + object X { val x = true; val y = "" } +} +\end{lstlisting} +The following program illustrates different kinds of bindings and +precedences between them. +\begin{lstlisting} +package P { // `X' bound by package clause +import Console._ // `println' bound by wildcard import +object A { + println("L4: "+X) // `X' refers to `P.X' here + object B { + import Q._ // `X' bound by wildcard import + println("L7: "+X) // `X' refers to `Q.X' here + import X._ // `x' and `y' bound by wildcard import + println("L8: "+x) // `x' refers to `Q.X.x' here + object C { + val x = 3 // `x' bound by local definition + println("L12: "+x) // `x' refers to constant `3' here + { import Q.X._ // `x' and `y' bound by wildcard import +// println("L14: "+x) // reference to `x' is ambiguous here + import X.y // `y' bound by explicit import + println("L16: "+y) // `y' refers to `Q.X.y' here + { val x = "abc" // `x' bound by local definition + import P.X._ // `x' and `y' bound by wildcard import +// println("L19: "+y) // reference to `y' is ambiguous here + println("L20: "+x) // `x' refers to string ``abc'' here +}}}}}} +\end{lstlisting} + +A reference to a qualified (type- or term-) identifier $e.x$ refers to +the member of the type $T$ of $e$ which has the name $x$ in the same +namespace as the identifier. It is an error if $T$ is not a value type +(\sref{sec:value-types}). The type of $e.x$ is the member type of the +referenced entity in $T$. + diff --git a/05-types.md b/05-types.md new file mode 100644 index 000000000000..104608da6ac9 --- /dev/null +++ b/05-types.md @@ -0,0 +1,1014 @@ +Types +===== + + +\syntax\begin{lstlisting} + Type ::= FunctionArgTypes `=>' Type + | InfixType [ExistentialClause] + FunctionArgTypes ::= InfixType + | `(' [ ParamType {`,' ParamType } ] `)' + ExistentialClause ::= `forSome' `{' ExistentialDcl {semi ExistentialDcl} `}' + ExistentialDcl ::= `type' TypeDcl + | `val' ValDcl + InfixType ::= CompoundType {id [nl] CompoundType} + CompoundType ::= AnnotType {`with' AnnotType} [Refinement] + | Refinement + AnnotType ::= SimpleType {Annotation} + SimpleType ::= SimpleType TypeArgs + | SimpleType `#' id + | StableId + | Path `.' `type' + | `(' Types ')' + TypeArgs ::= `[' Types `]' + Types ::= Type {`,' Type} +\end{lstlisting} + +We distinguish between first-order types and type constructors, which +take type parameters and yield types. A subset of first-order types +called {\em value types} represents sets of (first-class) values. +Value types are either {\em concrete} or {\em abstract}. + +Every concrete value type can be represented as a {\em class type}, i.e.\ a +type designator (\sref{sec:type-desig}) that refers to a +a class or a trait\footnote{We assume that objects and packages also implicitly +define a class (of the same name as the object or package, but +inaccessible to user programs).} (\sref{sec:class-defs}), or as a {\em +compound type} (\sref{sec:compound-types}) representing an +intersection of types, possibly with a refinement +(\sref{sec:refinements}) that further constrains the types of its +members. +\comment{A shorthand exists for denoting function types (\sref{sec:function-types}). } +Abstract value types are introduced by type parameters (\sref{sec:type-params}) +and abstract type bindings (\sref{sec:typedcl}). Parentheses in types can be used for +grouping. + +%@M +Non-value types capture properties of identifiers that are not values +(\sref{sec:synthetic-types}). For example, a type constructor (\sref{sec:higherkinded-types}) does not directly specify a type of values. However, when a type constructor is applied to the correct type arguments, it yields a first-order type, which may be a value type. + +Non-value types are expressed indirectly in Scala. E.g., a method type is described by writing down a method signature, which in itself is not a real type, although it gives rise to a corresponding method type (\sref{sec:method-types}). Type constructors are another example, as one can write \lstinline@type Swap[m[_, _], a,b] = m[b, a]@, but there is no syntax to write the corresponding anonymous type function directly. + +\section{Paths}\label{sec:paths}\label{sec:stable-ids} + +\syntax\begin{lstlisting} + Path ::= StableId + | [id `.'] this + StableId ::= id + | Path `.' id + | [id '.'] `super' [ClassQualifier] `.' id + ClassQualifier ::= `[' id `]' +\end{lstlisting} + +Paths are not types themselves, but they can be a part of named types +and in that function form a central role in Scala's type system. + +A path is one of the following. +\begin{itemize} +\item +The empty path $\epsilon$ (which cannot be written explicitly in user programs). +\item +\lstinline@$C$.this@, where $C$ references a class. +The path \code{this} is taken as a shorthand for \lstinline@$C$.this@ where +$C$ is the name of the class directly enclosing the reference. +\item +\lstinline@$p$.$x$@ where $p$ is a path and $x$ is a stable member of $p$. +{\em Stable members} are packages or members introduced by object definitions or +by value definitions of non-volatile types +(\sref{sec:volatile-types}). + +\item +\lstinline@$C$.super.$x$@ or \lstinline@$C$.super[$M\,$].$x$@ +where $C$ references a class and $x$ references a +stable member of the super class or designated parent class $M$ of $C$. +The prefix \code{super} is taken as a shorthand for \lstinline@$C$.super@ where +$C$ is the name of the class directly enclosing the reference. +\end{itemize} +A {\em stable identifier} is a path which ends in an identifier. + +\section{Value Types}\label{sec:value-types} + +Every value in Scala has a type which is of one of the following +forms. + +\subsection{Singleton Types} +\label{sec:singleton-types} +\label{sec:type-stability} + +\syntax\begin{lstlisting} + SimpleType ::= Path `.' type +\end{lstlisting} + +A singleton type is of the form \lstinline@$p$.type@, where $p$ is a +path pointing to a value expected to conform (\sref{sec:expr-typing}) +to \lstinline@scala.AnyRef@. The type denotes the set of values +consisting of \code{null} and the value denoted by $p$. + +A {\em stable type} is either a singleton type or a type which is +declared to be a subtype of trait \lstinline@scala.Singleton@. + +\subsection{Type Projection} +\label{sec:type-project} + +\syntax\begin{lstlisting} + SimpleType ::= SimpleType `#' id +\end{lstlisting} + +A type projection \lstinline@$T$#$x$@ references the type member named +$x$ of type $T$. +% The following is no longer necessary: +%If $x$ references an abstract type member, then $T$ must be a stable type (\sref{sec:singleton-types}). + +\subsection{Type Designators} +\label{sec:type-desig} + +\syntax\begin{lstlisting} + SimpleType ::= StableId +\end{lstlisting} + +A type designator refers to a named value type. It can be simple or +qualified. All such type designators are shorthands for type projections. + +Specifically, the unqualified type name $t$ where $t$ is bound in some +class, object, or package $C$ is taken as a shorthand for +\lstinline@$C$.this.type#$t$@. If $t$ is +not bound in a class, object, or package, then $t$ is taken as a +shorthand for \lstinline@$\epsilon$.type#$t$@. + +A qualified type designator has the form \lstinline@$p$.$t$@ where $p$ is +a path (\sref{sec:paths}) and $t$ is a type name. Such a type designator is +equivalent to the type projection \lstinline@$p$.type#$t$@. + +\example +Some type designators and their expansions are listed below. We assume +a local type parameter $t$, a value \code{maintable} +with a type member \code{Node} and the standard class \lstinline@scala.Int@, +\begin{lstlisting} + t $\epsilon$.type#t + Int scala.type#Int + scala.Int scala.type#Int + data.maintable.Node data.maintable.type#Node +\end{lstlisting} + +\subsection{Parameterized Types} +\label{sec:param-types} + +\syntax\begin{lstlisting} + SimpleType ::= SimpleType TypeArgs + TypeArgs ::= `[' Types `]' +\end{lstlisting} + +A parameterized type $T[U_1 \commadots U_n]$ consists of a type +designator $T$ and type parameters $U_1 \commadots U_n$ where $n \geq +1$. $T$ must refer to a type constructor which takes $n$ type +parameters $a_1 \commadots a_n$. + +Say the type parameters have lower bounds $L_1 \commadots L_n$ and +upper bounds $U_1 \commadots U_n$. The parameterized type is +well-formed if each actual type parameter {\em conforms to its +bounds}, i.e.\ $\sigma L_i <: T_i <: \sigma U_i$ where $\sigma$ is the +substitution $[a_1 := T_1 \commadots a_n := T_n]$. + +\example\label{ex:param-types} +Given the partial type definitions: + +\begin{lstlisting} + class TreeMap[A <: Comparable[A], B] { $\ldots$ } + class List[A] { $\ldots$ } + class I extends Comparable[I] { $\ldots$ } + + class F[M[_], X] { $\ldots$ } + class S[K <: String] { $\ldots$ } + class G[M[ Z <: I ], I] { $\ldots$ } +\end{lstlisting} + +the following parameterized types are well formed: + +\begin{lstlisting} + TreeMap[I, String] + List[I] + List[List[Boolean]] + + F[List, Int] + G[S, String] +\end{lstlisting} + +\example Given the type definitions of \ref{ex:param-types}, +the following types are ill-formed: + +\begin{lstlisting} + TreeMap[I] // illegal: wrong number of parameters + TreeMap[List[I], Int] // illegal: type parameter not within bound + + F[Int, Boolean] // illegal: Int is not a type constructor + F[TreeMap, Int] // illegal: TreeMap takes two parameters, + // F expects a constructor taking one + G[S, Int] // illegal: S constrains its parameter to + // conform to String, + // G expects type constructor with a parameter + // that conforms to Int +\end{lstlisting} + +\subsection{Tuple Types}\label{sec:tuple-types} + +\syntax\begin{lstlisting} + SimpleType ::= `(' Types ')' +\end{lstlisting} + +A tuple type \lstinline@($T_1 \commadots T_n$)@ is an alias for the +class ~\lstinline@scala.Tuple$n$[$T_1 \commadots T_n$]@, where $n \geq +2$. + +Tuple classes are case classes whose fields can be accessed using +selectors ~\code{_1}, ..., \lstinline@_$n$@. Their functionality is +abstracted in a corresponding \code{Product} trait. The $n$-ary tuple +class and product trait are defined at least as follows in the +standard Scala library (they might also add other methods and +implement other traits). + +\begin{lstlisting} +case class Tuple$n$[+T1, ..., +T$n$](_1: T1, ..., _$n$: T$n$) +extends Product$n$[T1, ..., T$n$] {} + +trait Product$n$[+T1, +T2, +T$n$] { + override def arity = $n$ + def _1: T1 + ... + def _$n$:T$n$ +} +\end{lstlisting} + +\subsection{Annotated Types} + +\syntax\begin{lstlisting} + AnnotType ::= SimpleType {Annotation} +\end{lstlisting} + +An annotated type ~$T$\lstinline@ $a_1 \ldots a_n$@ +attaches annotations $a_1 \commadots a_n$ to the type $T$ +(\sref{sec:annotations}). + +\example The following type adds the \code{@suspendable}@ annotation to the type +\code{String}: +\begin{lstlisting} + String @suspendable +\end{lstlisting} + +\subsection{Compound Types} +\label{sec:compound-types} +\label{sec:refinements} + +\syntax\begin{lstlisting} + CompoundType ::= AnnotType {`with' AnnotType} [Refinement] + | Refinement + Refinement ::= [nl] `{' RefineStat {semi RefineStat} `}' + RefineStat ::= Dcl + | `type' TypeDef + | +\end{lstlisting} + +A compound type ~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@~ +represents objects with members as given in the component types $T_1 +\commadots T_n$ and the refinement \lstinline@{$R\,$}@. A refinement +\lstinline@{$R\,$}@ contains declarations and type definitions. +If a declaration or definition overrides a declaration or definition in +one of the component types $T_1 \commadots T_n$, the usual rules for +overriding (\sref{sec:overriding}) apply; otherwise the declaration +or definition is said to be ``structural''\footnote{A reference to a +structurally defined member (method call or access to a value or +variable) may generate binary code that is significantly slower than +an equivalent code to a non-structural member.}. + +Within a method declaration in a structural refinement, the type of +any value parameter may only refer to type parameters or abstract +types that are contained inside the refinement. That is, it must refer +either to a type parameter of the method itself, or to a type +definition within the refinement. This restriction does not apply to +the function's result type. + +If no refinement is given, the empty refinement is implicitly added, +i.e.\ ~\lstinline@$T_1$ with $\ldots$ with $T_n$@~ is a shorthand for +~\lstinline@$T_1$ with $\ldots$ with $T_n$ {}@. + +A compound type may also consist of just a refinement +~\lstinline@{$R\,$}@ with no preceding component types. Such a type is +equivalent to ~\lstinline@AnyRef{$R\,$}@. + +\example The following example shows how to declare and use a function which parameter's type contains a refinement with structural declarations. +\begin{lstlisting}[escapechar=\%] + case class Bird (val name: String) extends Object { + def fly(height: Int) = ... + ... + } + case class Plane (val callsign: String) extends Object { + def fly(height: Int) = ... + ... + } + def takeoff( + runway: Int, + r: { val callsign: String; def fly(height: Int) }) = { + tower.print(r.callsign + " requests take-off on runway " + runway) + tower.read(r.callsign + " is clear f%%or take-off") + r.fly(1000) + } + val bird = new Bird("Polly the parrot"){ val callsign = name } + val a380 = new Plane("TZ-987") + takeoff(42, bird) + takeoff(89, a380) +\end{lstlisting} +Although ~\lstinline@Bird@ and ~\lstinline@Plane@ do not share any parent class other than ~\lstinline@Object@, the parameter ~\lstinline@r@ of function ~\lstinline@takeoff@ is defined using a refinement with structural declarations to accept any object that declares a value ~\lstinline@callsign@ and a ~\lstinline@fly@ function. + + +\subsection{Infix Types}\label{sec:infix-types} + +\syntax\begin{lstlisting} + InfixType ::= CompoundType {id [nl] CompoundType} +\end{lstlisting} +An infix type ~\lstinline@$T_1\;\op\;T_2$@~ consists of an infix +operator $\op$ which gets applied to two type operands $T_1$ and +$T_2$. The type is equivalent to the type application $\op[T_1, +T_2]$. The infix operator $\op$ may be an arbitrary identifier, +except for \code{*}, which is reserved as a postfix modifier +denoting a repeated parameter type (\sref{sec:repeated-params}). + +All type infix operators have the same precedence; parentheses have to +be used for grouping. The associativity (\sref{sec:infix-operations}) +of a type operator is determined as for term operators: type operators +ending in a colon `\lstinline@:@' are right-associative; all other +operators are left-associative. + +In a sequence of consecutive type infix operations $t_0; \op_1; t_1; +\op_2 \ldots \op_n; t_n$, all operators $\op_1 \commadots \op_n$ must have the same +associativity. If they are all left-associative, the sequence is +interpreted as $(\ldots(t_0;\op_1;t_1);\op_2\ldots);\op_n;t_n$, +otherwise it is interpreted as $t_0;\op_1;(t_1;\op_2;(\ldots\op_n;t_n)\ldots)$. + +\subsection{Function Types} +\label{sec:function-types} + +\syntax\begin{lstlisting} + Type ::= FunctionArgs `=>' Type + FunctionArgs ::= InfixType + | `(' [ ParamType {`,' ParamType } ] `)' +\end{lstlisting} +The type ~\lstinline@($T_1 \commadots T_n$) => $U$@~ represents the set of function +values that take arguments of types $T_1 \commadots T_n$ and yield +results of type $U$. In the case of exactly one argument type +~\lstinline@$T$ => $U$@~ is a shorthand for ~\lstinline@($T\,$) => $U$@. +An argument type of the form~\lstinline@=> T@ +represents a call-by-name parameter (\sref{sec:by-name-params}) of type $T$. + +Function types associate to the right, e.g. +~\lstinline@$S$ => $T$ => $U$@~ is the same as +~\lstinline@$S$ => ($T$ => $U$)@. + +Function types are shorthands for class types that define \code{apply} +functions. Specifically, the $n$-ary function type +~\lstinline@($T_1 \commadots T_n$) => U@~ is a shorthand for the class type +\lstinline@Function$n$[$T_1 \commadots T_n$,$U\,$]@. Such class +types are defined in the Scala library for $n$ between 0 and 9 as follows. +\begin{lstlisting} +package scala +trait Function$n$[-$T_1 \commadots$ -$T_n$, +$R$] { + def apply($x_1$: $T_1 \commadots x_n$: $T_n$): $R$ + override def toString = "" +} +\end{lstlisting} +Hence, function types are covariant (\sref{sec:variances}) in their +result type and contravariant in their argument types. + + +\subsection{Existential Types} +\label{sec:existential-types} + +\syntax\begin{lstlisting} + Type ::= InfixType ExistentialClauses + ExistentialClauses ::= `forSome' `{' ExistentialDcl + {semi ExistentialDcl} `}' + ExistentialDcl ::= `type' TypeDcl + | `val' ValDcl +\end{lstlisting} +An existential type has the form ~\lstinline@$T$ forSome {$\,Q\,$}@~ +where $Q$ is a sequence of type declarations \sref{sec:typedcl}. +Let $t_1[\tps_1] >: L_1 <: U_1 \commadots t_n[\tps_n] >: L_n <: U_n$ +be the types declared in $Q$ (any of the +type parameter sections \lstinline@[$\tps_i$]@ might be missing). +The scope of each type $t_i$ includes the type $T$ and the existential clause $Q$. +The type variables $t_i$ are said to be {\em bound} in the type ~\lstinline@$T$ forSome {$\,Q\,$}@. +Type variables which occur in a type $T$ but which are not bound in $T$ are said +to be {\em free} in $T$. + +A {\em type instance} of ~\lstinline@$T$ forSome {$\,Q\,$}@ +is a type $\sigma T$ where $\sigma$ is a substitution over $t_1 \commadots t_n$ +such that, for each $i$, $\sigma L_i \conforms \sigma t_i \conforms \sigma U_i$. +The set of values denoted by the existential type ~\lstinline@$T$ forSome {$\,Q\,$}@~ +is the union of the set of values of all its type instances. + +A {\em skolemization} of ~\lstinline@$T$ forSome {$\,Q\,$}@~ is +a type instance $\sigma T$, where $\sigma$ is the substitution +$[t'_1/t_1 \commadots t'_n/t_n]$ and each $t'_i$ is a fresh abstract type +with lower bound $\sigma L_i$ and upper bound $\sigma U_i$. + +\subsubsection*{Simplification Rules}\label{sec:ex-simpl} + +Existential types obey the following four equivalences: +\begin{enumerate} +\item +Multiple for-clauses in an existential type can be merged. E.g., +~\lstinline@$T$ forSome {$\,Q\,$} forSome {$\,Q'\,$}@~ +is equivalent to +~\lstinline@$T$ forSome {$\,Q\,$;$\,Q'\,$}@. +\item +Unused quantifications can be dropped. E.g., +~\lstinline@$T$ forSome {$\,Q\,$;$\,Q'\,$}@~ +where none of the types defined in $Q'$ are referred to by $T$ or $Q$, +is equivalent to +~\lstinline@$T$ forSome {$\,Q\,$}@. +\item +An empty quantification can be dropped. E.g., +~\lstinline@$T$ forSome { }@~ is equivalent to ~\lstinline@$T$@. +\item +An existential type ~\lstinline@$T$ forSome {$\,Q\,$}@~ where $Q$ contains +a clause ~\lstinline@type $t[\tps] >: L <: U$@ is equivalent +to the type ~\lstinline@$T'$ forSome {$\,Q\,$}@~ where $T'$ results from $T$ by replacing every +covariant occurrence (\sref{sec:variances}) of $t$ in $T$ by $U$ and by replacing every +contravariant occurrence of $t$ in $T$ by $L$. +\end{enumerate} + +\subsubsection*{Existential Quantification over Values}\label{sec:val-existential-types} + +As a syntactic convenience, the bindings clause +in an existential type may also contain +value declarations \lstinline@val $x$: $T$@. +An existential type ~\lstinline@$T$ forSome { $Q$; val $x$: $S\,$;$\,Q'$ }@~ +is treated as a shorthand for the type +~\lstinline@$T'$ forSome { $Q$; type $t$ <: $S$ with Singleton; $Q'$ }@, where $t$ is a fresh +type name and $T'$ results from $T$ by replacing every occurrence of +\lstinline@$x$.type@ with $t$. + +\subsubsection*{Placeholder Syntax for Existential Types}\label{sec:impl-existential-types} + +\syntax\begin{lstlisting} + WildcardType ::= `_' TypeBounds +\end{lstlisting} + +Scala supports a placeholder syntax for existential types. +A {\em wildcard type} is of the form ~\lstinline@_$\;$>:$\,L\,$<:$\,U$@. Both bound +clauses may be omitted. If a lower bound clause \lstinline@>:$\,L$@ is missing, +\lstinline@>:$\,$scala.Nothing@~ +is assumed. If an upper bound clause ~\lstinline@<:$\,U$@ is missing, +\lstinline@<:$\,$scala.Any@~ is assumed. A wildcard type is a shorthand for an +existentially quantified type variable, where the existential quantification is implicit. + +A wildcard type must appear as type argument of a parameterized type. +Let $T = p.c[\targs,T,\targs']$ be a parameterized type where $\targs, \targs'$ may be empty and +$T$ is a wildcard type ~\lstinline@_$\;$>:$\,L\,$<:$\,U$@. Then $T$ is equivalent to the existential +type +\begin{lstlisting} + $p.c[\targs,t,\targs']$ forSome { type $t$ >: $L$ <: $U$ } +\end{lstlisting} +where $t$ is some fresh type variable. +Wildcard types may also appear as parts of infix types +(\sref{sec:infix-types}), function types (\sref{sec:function-types}), +or tuple types (\sref{sec:tuple-types}). +Their expansion is then the expansion in the equivalent parameterized +type. + +\example Assume the class definitions +\begin{lstlisting} +class Ref[T] +abstract class Outer { type T } . +\end{lstlisting} +Here are some examples of existential types: +\begin{lstlisting} +Ref[T] forSome { type T <: java.lang.Number } +Ref[x.T] forSome { val x: Outer } +Ref[x_type # T] forSome { type x_type <: Outer with Singleton } +\end{lstlisting} +The last two types in this list are equivalent. +An alternative formulation of the first type above using wildcard syntax is: +\begin{lstlisting} +Ref[_ <: java.lang.Number] +\end{lstlisting} + +\example The type \lstinline@List[List[_]]@ is equivalent to the existential type +\begin{lstlisting} +List[List[t] forSome { type t }] . +\end{lstlisting} + +\example Assume a covariant type +\begin{lstlisting} +class List[+T] +\end{lstlisting} +The type +\begin{lstlisting} +List[T] forSome { type T <: java.lang.Number } +\end{lstlisting} +is equivalent (by simplification rule 4 above) to +\begin{lstlisting} +List[java.lang.Number] forSome { type T <: java.lang.Number } +\end{lstlisting} +which is in turn equivalent (by simplification rules 2 and 3 above) to +\lstinline@List[java.lang.Number]@. + +\section{Non-Value Types} +\label{sec:synthetic-types} + +The types explained in the following do not denote sets of values, nor +do they appear explicitly in programs. They are introduced in this +report as the internal types of defined identifiers. + +\subsection{Method Types} +\label{sec:method-types} + +A method type is denoted internally as $(\Ps)U$, where $(\Ps)$ is a +sequence of parameter names and types $(p_1:T_1 \commadots p_n:T_n)$ +for some $n \geq 0$ and $U$ is a (value or method) type. This type +represents named methods that take arguments named $p_1 \commadots p_n$ +of types $T_1 \commadots T_n$ +and that return a result of type $U$. + +Method types associate to the right: $(\Ps_1)(\Ps_2)U$ is +treated as $(\Ps_1)((\Ps_2)U)$. + +A special case are types of methods without any parameters. They are +written here \lstinline@=> T@. Parameterless methods name expressions +that are re-evaluated each time the parameterless method name is +referenced. + +Method types do not exist as types of values. If a method name is used +as a value, its type is implicitly converted to a corresponding +function type (\sref{sec:impl-conv}). + +\example The declarations +\begin{lstlisting} +def a: Int +def b (x: Int): Boolean +def c (x: Int) (y: String, z: String): String +\end{lstlisting} +produce the typings +\begin{lstlisting} +a: => Int +b: (Int) Boolean +c: (Int) (String, String) String +\end{lstlisting} + +\subsection{Polymorphic Method Types} +\label{sec:poly-types} + +A polymorphic method type is denoted internally as ~\lstinline@[$\tps\,$]$T$@~ where +\lstinline@[$\tps\,$]@ is a type parameter section +~\lstinline@[$a_1$ >: $L_1$ <: $U_1 \commadots a_n$ >: $L_n$ <: $U_n$]@~ +for some $n \geq 0$ and $T$ is a +(value or method) type. This type represents named methods that +take type arguments ~\lstinline@$S_1 \commadots S_n$@~ which +conform (\sref{sec:param-types}) to the lower bounds +~\lstinline@$L_1 \commadots L_n$@~ and the upper bounds +~\lstinline@$U_1 \commadots U_n$@~ and that yield results of type $T$. + +\example The declarations +\begin{lstlisting} +def empty[A]: List[A] +def union[A <: Comparable[A]] (x: Set[A], xs: Set[A]): Set[A] +\end{lstlisting} +produce the typings +\begin{lstlisting} +empty : [A >: Nothing <: Any] List[A] +union : [A >: Nothing <: Comparable[A]] (x: Set[A], xs: Set[A]) Set[A] . +\end{lstlisting} + +\subsection{Type Constructors} %@M +\label{sec:higherkinded-types} +A type constructor is represented internally much like a polymorphic method type. +~\lstinline@[$\pm$ $a_1$ >: $L_1$ <: $U_1 \commadots \pm a_n$ >: $L_n$ <: $U_n$] $T$@~ represents a type that is expected by a type constructor parameter (\sref{sec:type-params}) or an abstract type constructor binding (\sref{sec:typedcl}) with the corresponding type parameter clause. + +\example Consider this fragment of the \lstinline@Iterable[+X]@ class: +\begin{lstlisting} +trait Iterable[+X] { + def flatMap[newType[+X] <: Iterable[X], S](f: X => newType[S]): newType[S] +} +\end{lstlisting} + +Conceptually, the type constructor \lstinline@Iterable@ is a name for the anonymous type \lstinline@[+X] Iterable[X]@, which may be passed to the \lstinline@newType@ type constructor parameter in \lstinline@flatMap@. + +\comment{ +\subsection{Overloaded Types} +\label{sec:overloaded-types} + +More than one values or methods are defined in the same scope with the +same name, we model + +An overloaded type consisting of type alternatives $T_1 \commadots +T_n (n \geq 2)$ is denoted internally $T_1 \overload \ldots \overload T_n$. + +\example The definitions +\begin{lstlisting} +def println: Unit +def println(s: String): Unit = $\ldots$ +def println(x: Float): Unit = $\ldots$ +def println(x: Float, width: Int): Unit = $\ldots$ +def println[A](x: A)(tostring: A => String): Unit = $\ldots$ +\end{lstlisting} +define a single function \code{println} which has an overloaded +type. +\begin{lstlisting} +println: => Unit $\overload$ + (String) Unit $\overload$ + (Float) Unit $\overload$ + (Float, Int) Unit $\overload$ + [A] (A) (A => String) Unit +\end{lstlisting} + +\example The definitions +\begin{lstlisting} +def f(x: T): T = $\ldots$ +val f = 0 +\end{lstlisting} +define a function \code{f} which has type ~\lstinline@(x: T)T $\overload$ Int@. +} + +\section{Base Types and Member Definitions} +\label{sec:base-classes-member-defs} + +Types of class members depend on the way the members are referenced. +Central here are three notions, namely: +\begin{enumerate} +\item the notion of the set of base types of a type $T$, +\item the notion of a type $T$ in some class $C$ seen from some + prefix type $S$, +\item the notion of the set of member bindings of some type $T$. +\end{enumerate} +These notions are defined mutually recursively as follows. + +1. The set of {\em base types} of a type is a set of class types, +given as follows. +\begin{itemize} +\item +The base types of a class type $C$ with parents $T_1 \commadots T_n$ are +$C$ itself, as well as the base types of the compound type +~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@. +\item +The base types of an aliased type are the base types of its alias. +\item +The base types of an abstract type are the base types of its upper bound. +\item +The base types of a parameterized type +~\lstinline@$C$[$T_1 \commadots T_n$]@~ are the base types +of type $C$, where every occurrence of a type parameter $a_i$ +of $C$ has been replaced by the corresponding parameter type $T_i$. +\item +The base types of a singleton type \lstinline@$p$.type@ are the base types of +the type of $p$. +\item +The base types of a compound type +~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@~ +are the {\em reduced union} of the base +classes of all $T_i$'s. This means: +Let the multi-set $\SS$ be the multi-set-union of the +base types of all $T_i$'s. +If $\SS$ contains several type instances of the same class, say +~\lstinline@$S^i$#$C$[$T^i_1 \commadots T^i_n$]@~ $(i \in I)$, then +all those instances +are replaced by one of them which conforms to all +others. It is an error if no such instance exists. It follows that the reduced union, if it exists, +produces a set of class types, where different types are instances of different classes. +\item +The base types of a type selection \lstinline@$S$#$T$@ are +determined as follows. If $T$ is an alias or abstract type, the +previous clauses apply. Otherwise, $T$ must be a (possibly +parameterized) class type, which is defined in some class $B$. Then +the base types of \lstinline@$S$#$T$@ are the base types of $T$ +in $B$ seen from the prefix type $S$. +\item +The base types of an existential type \lstinline@$T$ forSome {$\,Q\,$}@ are +all types \lstinline@$S$ forSome {$\,Q\,$}@ where $S$ is a base type of $T$. +\end{itemize} + +2. The notion of a type $T$ +{\em in class $C$ seen from some prefix type +$S\,$} makes sense only if the prefix type $S$ +has a type instance of class $C$ as a base type, say +~\lstinline@$S'$#$C$[$T_1 \commadots T_n$]@. Then we define as follows. +\begin{itemize} + \item + If \lstinline@$S$ = $\epsilon$.type@, then $T$ in $C$ seen from $S$ is $T$ itself. + \item + Otherwise, if $S$ is an existential type ~\lstinline@$S'$ forSome {$\,Q\,$}@, and + $T$ in $C$ seen from $S'$ is $T'$, + then $T$ in $C$ seen from $S$ is ~\lstinline@$T'$ forSome {$\,Q\,$}@. + \item + Otherwise, if $T$ is the $i$'th type parameter of some class $D$, then + \begin{itemize} + \item + If $S$ has a base type ~\lstinline@$D$[$U_1 \commadots U_n$]@, for some type parameters + ~\lstinline@[$U_1 \commadots U_n$]@, then $T$ in $C$ seen from $S$ is $U_i$. + \item + Otherwise, if $C$ is defined in a class $C'$, then + $T$ in $C$ seen from $S$ is the same as $T$ in $C'$ seen from $S'$. + \item + Otherwise, if $C$ is not defined in another class, then + $T$ in $C$ seen from $S$ is $T$ itself. + \end{itemize} +\item + Otherwise, + if $T$ is the singleton type \lstinline@$D$.this.type@ for some class $D$ + then + \begin{itemize} + \item + If $D$ is a subclass of $C$ and + $S$ has a type instance of class $D$ among its base types, + then $T$ in $C$ seen from $S$ is $S$. + \item + Otherwise, if $C$ is defined in a class $C'$, then + $T$ in $C$ seen from $S$ is the same as $T$ in $C'$ seen from $S'$. + \item + Otherwise, if $C$ is not defined in another class, then + $T$ in $C$ seen from $S$ is $T$ itself. + \end{itemize} +\item + If $T$ is some other type, then the described mapping is performed + to all its type components. +\end{itemize} + +If $T$ is a possibly parameterized class type, where $T$'s class +is defined in some other class $D$, and $S$ is some prefix type, +then we use ``$T$ seen from $S$'' as a shorthand for +``$T$ in $D$ seen from $S$''. + +3. The {\em member bindings} of a type $T$ are (1) all bindings $d$ such that +there exists a type instance of some class $C$ among the base types of $T$ +and there exists a definition or declaration $d'$ in $C$ +such that $d$ results from $d'$ by replacing every +type $T'$ in $d'$ by $T'$ in $C$ seen from $T$, and (2) all bindings +of the type's refinement (\sref{sec:refinements}), if it has one. + +The {\em definition} of a type projection \lstinline@$S$#$t$@ is the member +binding $d_t$ of the type $t$ in $S$. In that case, we also say +that \lstinline@$S$#$t$@ {\em is defined by} $d_t$. +share a to +\section{Relations between types} + +We define two relations between types. +\begin{quote}\begin{tabular}{l@{\gap}l@{\gap}l} +\em Type equivalence & $T \equiv U$ & $T$ and $U$ are interchangeable +in all contexts. +\\ +\em Conformance & $T \conforms U$ & Type $T$ conforms to type $U$. +\end{tabular}\end{quote} + +\subsection{Type Equivalence} +\label{sec:type-equiv} + +Equivalence $(\equiv)$ between types is the smallest congruence\footnote{ A +congruence is an equivalence relation which is closed under formation +of contexts} such that the following holds: +\begin{itemize} +\item +If $t$ is defined by a type alias ~\lstinline@type $t$ = $T$@, then $t$ is +equivalent to $T$. +\item +If a path $p$ has a singleton type ~\lstinline@$q$.type@, then +~\lstinline@$p$.type $\equiv q$.type@. +\item +If $O$ is defined by an object definition, and $p$ is a path +consisting only of package or object selectors and ending in $O$, then +~\lstinline@$O$.this.type $\equiv p$.type@. +\item +Two compound types (\sref{sec:compound-types}) are equivalent if the sequences of their component +are pairwise equivalent, and occur in the same order, and their +refinements are equivalent. Two refinements are equivalent if they +bind the same names and the modifiers, types and bounds of every +declared entity are equivalent in both refinements. +\item +Two method types (\sref{sec:method-types}) are equivalent if they have equivalent result types, +both have the same number of parameters, and corresponding parameters +have equivalent types. Note that the names of parameters do not +matter for method type equivalence. +\item +Two polymorphic method types (\sref{sec:poly-types}) are equivalent if they have the same number of +type parameters, and, after renaming one set of type parameters by +another, the result types as well as lower and upper bounds of +corresponding type parameters are equivalent. +\item +Two existential types (\sref{sec:existential-types}) +are equivalent if they have the same number of +quantifiers, and, after renaming one list of type quantifiers by +another, the quantified types as well as lower and upper bounds of +corresponding quantifiers are equivalent. +\item %@M +Two type constructors (\sref{sec:higherkinded-types}) are equivalent if they have the +same number of type parameters, and, after renaming one list of type parameters by +another, the result types as well as variances, lower and upper bounds of +corresponding type parameters are equivalent. +\end{itemize} + +\subsection{Conformance} +\label{sec:conformance} + +The conformance relation $(\conforms)$ is the smallest +transitive relation that satisfies the following conditions. +\begin{itemize} +\item Conformance includes equivalence. If $T \equiv U$ then $T \conforms U$. +\item For every value type $T$, + $\mbox{\code{scala.Nothing}} \conforms T \conforms \mbox{\code{scala.Any}}$. +\item For every type constructor $T$ (with any number of type parameters), + $\mbox{\code{scala.Nothing}} \conforms T \conforms \mbox{\code{scala.Any}}$. %@M + +\item For every class type $T$ such that $T \conforms + \mbox{\code{scala.AnyRef}}$ and not $T \conforms \mbox{\code{scala.NotNull}}$ + one has $\mbox{\code{scala.Null}} \conforms T$. +\item A type variable or abstract type $t$ conforms to its upper bound and + its lower bound conforms to $t$. +\item A class type or parameterized type conforms to any of its + base-types. +\item A singleton type \lstinline@$p$.type@ conforms to the type of + the path $p$. +\item A singleton type \lstinline@$p$.type@ conforms to the type $\mbox{\code{scala.Singleton}}$. +\item A type projection \lstinline@$T$#$t$@ conforms to \lstinline@$U$#$t$@ if + $T$ conforms to $U$. +\item A parameterized type ~\lstinline@$T$[$T_1 \commadots T_n$]@~ conforms to + ~\lstinline@$T$[$U_1 \commadots U_n$]@~ if + the following three conditions hold for $i = 1 \commadots n$. + \begin{itemize} + \item + If the $i$'th type parameter of $T$ is declared covariant, then $T_i \conforms U_i$. + \item + If the $i$'th type parameter of $T$ is declared contravariant, then $U_i \conforms T_i$. + \item + If the $i$'th type parameter of $T$ is declared neither covariant + nor contravariant, then $U_i \equiv T_i$. + \end{itemize} +\item A compound type ~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@~ conforms to + each of its component types $T_i$. +\item If $T \conforms U_i$ for $i = 1 \commadots n$ and for every + binding $d$ of a type or value $x$ in $R$ there exists a member + binding of $x$ in $T$ which subsumes $d$, then $T$ conforms to the + compound type ~\lstinline@$U_1$ with $\ldots$ with $U_n$ {$R\,$}@. +\item The existential type ~\lstinline@$T$ forSome {$\,Q\,$}@ conforms to + $U$ if its skolemization (\sref{sec:existential-types}) + conforms to $U$. +\item The type $T$ conforms to the existential type ~\lstinline@$U$ forSome {$\,Q\,$}@ + if $T$ conforms to one of the type instances (\sref{sec:existential-types}) + of ~\lstinline@$U$ forSome {$\,Q\,$}@. +\item If + $T_i \equiv T'_i$ for $i = 1 \commadots n$ and $U$ conforms to $U'$ + then the method type $(p_1:T_1 \commadots p_n:T_n) U$ conforms to + $(p'_1:T'_1 \commadots p'_n:T'_n) U'$. +\item The polymorphic type +$[a_1 >: L_1 <: U_1 \commadots a_n >: L_n <: U_n] T$ conforms to the polymorphic type +$[a_1 >: L'_1 <: U'_1 \commadots a_n >: L'_n <: U'_n] T'$ if, assuming +$L'_1 \conforms a_1 \conforms U'_1 \commadots L'_n \conforms a_n \conforms U'_n$ +one has $T \conforms T'$ and $L_i \conforms L'_i$ and $U'_i \conforms U_i$ +for $i = 1 \commadots n$. +%@M +\item Type constructors $T$ and $T'$ follow a similar discipline. We characterize $T$ and $T'$ by their type parameter clauses +$[a_1 \commadots a_n]$ and +$[a'_1 \commadots a'_n ]$, where an $a_i$ or $a'_i$ may include a variance annotation, a higher-order type parameter clause, and bounds. Then, $T$ conforms to $T'$ if any list $[t_1 \commadots t_n]$ -- with declared variances, bounds and higher-order type parameter clauses -- of valid type arguments for $T'$ is also a valid list of type arguments for $T$ and $T[t_1 \commadots t_n] \conforms T'[t_1 \commadots t_n]$. Note that this entails that: + \begin{itemize} + \item + The bounds on $a_i$ must be weaker than the corresponding bounds declared for $a'_i$. + \item + The variance of $a_i$ must match the variance of $a'_i$, where covariance matches covariance, contravariance matches contravariance and any variance matches invariance. + \item + Recursively, these restrictions apply to the corresponding higher-order type parameter clauses of $a_i$ and $a'_i$. + \end{itemize} + +\end{itemize} + +A declaration or definition in some compound type of class type $C$ +{\em subsumes} another +declaration of the same name in some compound type or class type $C'$, if one of the following holds. +\begin{itemize} +\item +A value declaration or definition that defines a name $x$ with type $T$ subsumes +a value or method declaration that defines $x$ with type $T'$, provided $T \conforms T'$. +\item +A method declaration or definition that defines a name $x$ with type $T$ subsumes +a method declaration that defines $x$ with type $T'$, provided $T \conforms T'$. +\item +A type alias +$\TYPE;t[T_1 \commadots T_n]=T$ subsumes a type alias $\TYPE;t[T_1 \commadots T_n]=T'$ if %@M +$T \equiv T'$. +\item +A type declaration ~\lstinline@type $t$[$T_1 \commadots T_n$] >: $L$ <: $U$@~ subsumes %@M +a type declaration ~\lstinline@type $t$[$T_1 \commadots T_n$] >: $L'$ <: $U'$@~ if $L' \conforms L$ and %@M +$U \conforms U'$. +\item +A type or class definition that binds a type name $t$ subsumes an abstract +type declaration ~\lstinline@type t[$T_1 \commadots T_n$] >: L <: U@~ if %@M +$L \conforms t \conforms U$. +\end{itemize} + +The $(\conforms)$ relation forms pre-order between types, +i.e.\ it is transitive and reflexive. {\em +least upper bounds} and {\em greatest lower bounds} of a set of types +are understood to be relative to that order. + +\paragraph{Note} The least upper bound or greatest lower bound +of a set of types does not always exist. For instance, consider +the class definitions +\begin{lstlisting} +class A[+T] {} +class B extends A[B] +class C extends A[C] +\end{lstlisting} +Then the types ~\lstinline@A[Any], A[A[Any]], A[A[A[Any]]], ...@~ form +a descending sequence of upper bounds for \code{B} and \code{C}. The +least upper bound would be the infinite limit of that sequence, which +does not exist as a Scala type. Since cases like this are in general +impossible to detect, a Scala compiler is free to reject a term +which has a type specified as a least upper or greatest lower bound, +and that bound would be more complex than some compiler-set +limit\footnote{The current Scala compiler limits the nesting level +of parameterization in such bounds to be at most two deeper than the maximum +nesting level of the operand types}. + +The least upper bound or greatest lower bound might also not be +unique. For instance \code{A with B} and \code{B with A} are both +greatest lower of \code{A} and \code{B}. If there are several +least upper bounds or greatest lower bounds, the Scala compiler is +free to pick any one of them. + +\subsection{Weak Conformance}\label{sec:weakconformance} + +In some situations Scala uses a more genral conformance relation. A +type $S$ {\em weakly conforms} +to a type $T$, written $S \conforms_w +T$, if $S \conforms T$ or both $S$ and $T$ are primitive number types +and $S$ precedes $T$ in the following ordering. +\begin{lstlisting} +Byte $\conforms_w$ Short +Short $\conforms_w$ Int +Char $\conforms_w$ Int +Int $\conforms_w$ Long +Long $\conforms_w$ Float +Float $\conforms_w$ Double +\end{lstlisting} + +A {\em weak least upper bound} is a least upper bound with respect to +weak conformance. + +\section{Volatile Types} +\label{sec:volatile-types} + +Type volatility approximates the possibility that a type parameter or abstract type instance +of a type does not have any non-null values. As explained in +(\sref{sec:paths}), a value member of a volatile type cannot appear in +a path. + +A type is {\em volatile} if it falls into one of four categories: + +A compound type ~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@~ +is volatile if one of the following two conditions hold. +\begin{enumerate} +\item One of $T_2 \commadots T_n$ is a type parameter or abstract type, or +\item $T_1$ is an abstract type and and either the refinement $R$ + or a type $T_j$ for $j > 1$ contributes an abstract member + to the compound type, or +\item one of $T_1 \commadots T_n$ is a singleton type. +\end{enumerate} +Here, a type $S$ {\em contributes an abstract member} to a type $T$ if +$S$ contains an abstract member that is also a member of $T$. +A refinement $R$ contributes an abstract member to a type $T$ if $R$ +contains an abstract declaration which is also a member of $T$. + +A type designator is volatile if it is an alias of a volatile type, or +if it designates a type parameter or abstract type that has a volatile type as its +upper bound. + +A singleton type \lstinline@$p$.type@ is volatile, if the underlying +type of path $p$ is volatile. + +An existential type ~\lstinline@$T$ forSome {$\,Q\,$}@~ is volatile if +$T$ is volatile. + +\section{Type Erasure} +\label{sec:erasure} + +A type is called {\em generic} if it contains type arguments or type variables. +{\em Type erasure} is a mapping from (possibly generic) types to +non-generic types. We write $|T|$ for the erasure of type $T$. +The erasure mapping is defined as follows. +\begin{itemize} +\item The erasure of an alias type is the erasure of its right-hand side. %@M +\item The erasure of an abstract type is the erasure of its upper bound. +\item The erasure of the parameterized type \lstinline@scala.Array$[T_1]$@ is + \lstinline@scala.Array$[|T_1|]$@. + \item The erasure of every other parameterized type $T[T_1 \commadots T_n]$ is $|T|$. +\item The erasure of a singleton type \lstinline@$p$.type@ is the + erasure of the type of $p$. +\item The erasure of a type projection \lstinline@$T$#$x$@ is \lstinline@|$T$|#$x$@. +\item The erasure of a compound type +~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@ is the erasure of the intersection dominator of + $T_1 \commadots T_n$. +\item The erasure of an existential type ~\lstinline@$T$ forSome {$\,Q\,$}@ + is $|T|$. +\end{itemize} + +The {\em intersection dominator} of a list of types $T_1 \commadots +T_n$ is computed as follows. +Let $T_{i_1} \commadots T_{i_m}$ be the subsequence of types $T_i$ +which are not supertypes of some other type $T_j$. +If this subsequence contains a type designator $T_c$ that refers to a class which is not a trait, +the intersection dominator is $T_c$. Otherwise, the intersection +dominator is the first element of the subsequence, $T_{i_1}$. + diff --git a/06-basic-declarations-and-definitions.md b/06-basic-declarations-and-definitions.md new file mode 100644 index 000000000000..e2e32ffd06c6 --- /dev/null +++ b/06-basic-declarations-and-definitions.md @@ -0,0 +1,935 @@ +Basic Declarations and Definitions +================================== + + +\syntax\begin{lstlisting} + Dcl ::= `val' ValDcl + | `var' VarDcl + | `def' FunDcl + | `type' {nl} TypeDcl + PatVarDef ::= `val' PatDef + | `var' VarDef + Def ::= PatVarDef + | `def' FunDef + | `type' {nl} TypeDef + | TmplDef +\end{lstlisting} + +A {\em declaration} introduces names and assigns them types. It can +form part of a class definition (\sref{sec:templates}) or of a +refinement in a compound type (\sref{sec:refinements}). + +A {\em definition} introduces names that denote terms or types. It can +form part of an object or class definition or it can be local to a +block. Both declarations and definitions produce {\em bindings} that +associate type names with type definitions or bounds, and that +associate term names with types. + +The scope of a name introduced by a declaration or definition is the +whole statement sequence containing the binding. However, there is a +restriction on forward references in blocks: In a statement sequence +$s_1 \ldots s_n$ making up a block, if a simple name in $s_i$ refers +to an entity defined by $s_j$ where $j \geq i$, then for all $s_k$ +between and including $s_i$ and $s_j$, +\begin{itemize} +\item $s_k$ cannot be a variable definition. +\item If $s_k$ is a value definition, it must be lazy. +\end{itemize} + +\comment{ +Every basic definition may introduce several defined names, separated +by commas. These are expanded according to the following scheme: +\bda{lcl} +\VAL;x, y: T = e && \VAL; x: T = e \\ + && \VAL; y: T = x \\[0.5em] + +\LET;x, y: T = e && \LET; x: T = e \\ + && \VAL; y: T = x \\[0.5em] + +\DEF;x, y (ps): T = e &\tab\mbox{expands to}\tab& \DEF; x(ps): T = e \\ + && \DEF; y(ps): T = x(ps)\\[0.5em] + +\VAR;x, y: T := e && \VAR;x: T := e\\ + && \VAR;y: T := x\\[0.5em] + +\TYPE;t,u = T && \TYPE; t = T\\ + && \TYPE; u = t\\[0.5em] +\eda + +All definitions have a ``repeated form'' where the initial +definition keyword is followed by several constituent definitions +which are separated by commas. A repeated definition is +always interpreted as a sequence formed from the +constituent definitions. E.g.\ the function definition +~\lstinline@def f(x) = x, g(y) = y@~ expands to +~\lstinline@def f(x) = x; def g(y) = y@~ and +the type definition +~\lstinline@type T, U <: B@~ expands to +~\lstinline@type T; type U <: B@. +} +\comment{ +If an element in such a sequence introduces only the defined name, +possibly with some type or value parameters, but leaves out any +additional parts in the definition, then those parts are implicitly +copied from the next subsequent sequence element which consists of +more than just a defined name and parameters. Examples: +\begin{itemize} +\item[] +The variable declaration ~\lstinline@var x, y: Int@~ +expands to ~\lstinline@var x: Int; var y: Int@. +\item[] +The value definition ~\lstinline@val x, y: Int = 1@~ +expands to ~\lstinline@val x: Int = 1; val y: Int = 1@. +\item[] +The class definition ~\lstinline@case class X(), Y(n: Int) extends Z@~ expands to +~\lstinline@case class X extends Z; case class Y(n: Int) extends Z@. +\item +The object definition ~\lstinline@case object Red, Green, Blue extends Color@~ +expands to +\begin{lstlisting} +case object Red extends Color +case object Green extends Color +case object Blue extends Color . +\end{lstlisting} +\end{itemize} +} +\section{Value Declarations and Definitions} +\label{sec:valdef} + +\syntax\begin{lstlisting} + Dcl ::= `val' ValDcl + ValDcl ::= ids `:' Type + PatVarDef ::= `val' PatDef + PatDef ::= Pattern2 {`,' Pattern2} [`:' Type] `=' Expr + ids ::= id {`,' id} +\end{lstlisting} + +A value declaration ~\lstinline@val $x$: $T$@~ introduces $x$ as a name of a value of +type $T$. + +A value definition ~\lstinline@val $x$: $T$ = $e$@~ defines $x$ as a +name of the value that results from the evaluation of $e$. +If the value definition is not recursive, the type +$T$ may be omitted, in which case the packed type (\sref{sec:expr-typing}) of expression $e$ is +assumed. If a type $T$ is given, then $e$ is expected to conform to +it. + +Evaluation of the value definition implies evaluation of its +right-hand side $e$, unless it has the modifier \lstinline@lazy@. The +effect of the value definition is to bind $x$ to the value of $e$ +converted to type $T$. A \lstinline@lazy@ value definition evaluates +its right hand side $e$ the first time the value is accessed. + +A {\em constant value definition} is of the form +\begin{lstlisting} +final val x = e +\end{lstlisting} +where \lstinline@e@ is a constant expression +(\sref{sec:constant-expression}). +The \lstinline@final@ modifier must be +present and no type annotation may be given. References to the +constant value \lstinline@x@ are themselves treated as constant expressions; in the +generated code they are replaced by the definition's right-hand side \lstinline@e@. + +Value definitions can alternatively have a pattern +(\sref{sec:patterns}) as left-hand side. If $p$ is some pattern other +than a simple name or a name followed by a colon and a type, then the +value definition ~\lstinline@val $p$ = $e$@~ is expanded as follows: + +1. If the pattern $p$ has bound variables $x_1 \commadots x_n$, where $n > 1$: +\begin{lstlisting} +val $\Dollar x$ = $e$ match {case $p$ => {$x_1 \commadots x_n$}} +val $x_1$ = $\Dollar x$._1 +$\ldots$ +val $x_n$ = $\Dollar x$._n . +\end{lstlisting} +Here, $\Dollar x$ is a fresh name. + +2. If $p$ has a unique bound variable $x$: +\begin{lstlisting} +val $x$ = $e$ match { case $p$ => $x$ } +\end{lstlisting} + +3. If $p$ has no bound variables: +\begin{lstlisting} +$e$ match { case $p$ => ()} +\end{lstlisting} + +\example +The following are examples of value definitions +\begin{lstlisting} +val pi = 3.1415 +val pi: Double = 3.1415 // equivalent to first definition +val Some(x) = f() // a pattern definition +val x :: xs = mylist // an infix pattern definition +\end{lstlisting} + +The last two definitions have the following expansions. +\begin{lstlisting} +val x = f() match { case Some(x) => x } + +val x$\Dollar$ = mylist match { case x :: xs => {x, xs} } +val x = x$\Dollar$._1 +val xs = x$\Dollar$._2 +\end{lstlisting} + +The name of any declared or defined value may not end in \lstinline@_=@. + +A value declaration ~\lstinline@val $x_1 \commadots x_n$: $T$@~ +is a +shorthand for the sequence of value declarations +~\lstinline@val $x_1$: $T$; ...; val $x_n$: $T$@. +A value definition ~\lstinline@val $p_1 \commadots p_n$ = $e$@~ +is a +shorthand for the sequence of value definitions +~\lstinline@val $p_1$ = $e$; ...; val $p_n$ = $e$@. +A value definition ~\lstinline@val $p_1 \commadots p_n: T$ = $e$@~ +is a +shorthand for the sequence of value definitions +~\lstinline@val $p_1: T$ = $e$; ...; val $p_n: T$ = $e$@. + +\section{Variable Declarations and Definitions} +\label{sec:vardef} + +\syntax\begin{lstlisting} + Dcl ::= `var' VarDcl + PatVarDef ::= `var' VarDef + VarDcl ::= ids `:' Type + VarDef ::= PatDef + | ids `:' Type `=' `_' +\end{lstlisting} + +A variable declaration ~\lstinline@var $x$: $T$@~ is equivalent to declarations +of a {\em getter function} $x$ and a {\em setter function} +\lstinline@$x$_=@, defined as follows: + +\begin{lstlisting} + def $x$: $T$ + def $x$_= ($y$: $T$): Unit +\end{lstlisting} + +An implementation of a class containing variable declarations +may define these variables using variable definitions, or it may +define setter and getter functions directly. + +A variable definition ~\lstinline@var $x$: $T$ = $e$@~ introduces a +mutable variable with type $T$ and initial value as given by the +expression $e$. The type $T$ can be omitted, in which case the type of +$e$ is assumed. If $T$ is given, then $e$ is expected to conform to it +(\sref{sec:expr-typing}). + +Variable definitions can alternatively have a pattern +(\sref{sec:patterns}) as left-hand side. A variable definition + ~\lstinline@var $p$ = $e$@~ where $p$ is a pattern other +than a simple name or a name followed by a colon and a type is expanded in the same way +(\sref{sec:valdef}) +as a value definition ~\lstinline@val $p$ = $e$@, except that +the free names in $p$ are introduced as mutable variables, not values. + +The name of any declared or defined variable may not end in \lstinline@_=@. + +A variable definition ~\lstinline@var $x$: $T$ = _@~ can appear only +as a member of a template. It introduces a mutable field with type +\ $T$ and a default initial value. The default value depends on the +type $T$ as follows: +\begin{quote}\begin{tabular}{ll} +\code{0} & if $T$ is \code{Int} or one of its subrange types, \\ +\code{0L} & if $T$ is \code{Long},\\ +\lstinline@0.0f@ & if $T$ is \code{Float},\\ +\lstinline@0.0d@ & if $T$ is \code{Double},\\ +\code{false} & if $T$ is \code{Boolean},\\ +\lstinline@{}@ & if $T$ is \code{Unit}, \\ +\code{null} & for all other types $T$. +\end{tabular}\end{quote} +When they occur as members of a template, both forms of variable +definition also introduce a getter function $x$ which returns the +value currently assigned to the variable, as well as a setter function +\lstinline@$x$_=@ which changes the value currently assigned to the variable. +The functions have the same signatures as for a variable declaration. +The template then has these getter and setter functions as +members, whereas the original variable cannot be accessed directly as +a template member. + +\example The following example shows how {\em properties} can be +simulated in Scala. It defines a class \code{TimeOfDayVar} of time +values with updatable integer fields representing hours, minutes, and +seconds. Its implementation contains tests that allow only legal +values to be assigned to these fields. The user code, on the other +hand, accesses these fields just like normal variables. + +\begin{lstlisting} +class TimeOfDayVar { + private var h: Int = 0 + private var m: Int = 0 + private var s: Int = 0 + + def hours = h + def hours_= (h: Int) = if (0 <= h && h < 24) this.h = h + else throw new DateError() + + def minutes = m + def minutes_= (m: Int) = if (0 <= m && m < 60) this.m = m + else throw new DateError() + + def seconds = s + def seconds_= (s: Int) = if (0 <= s && s < 60) this.s = s + else throw new DateError() +} +val d = new TimeOfDayVar +d.hours = 8; d.minutes = 30; d.seconds = 0 +d.hours = 25 // throws a DateError exception +\end{lstlisting} + +A variable declaration ~\lstinline@var $x_1 \commadots x_n$: $T$@~ +is a +shorthand for the sequence of variable declarations +~\lstinline@var $x_1$: $T$; ...; var $x_n$: $T$@. +A variable definition ~\lstinline@var $x_1 \commadots x_n$ = $e$@~ +is a +shorthand for the sequence of variable definitions +~\lstinline@var $x_1$ = $e$; ...; var $x_n$ = $e$@. +A variable definition ~\lstinline@var $x_1 \commadots x_n: T$ = $e$@~ +is a +shorthand for the sequence of variable definitions +~\lstinline@var $x_1: T$ = $e$; ...; var $x_n: T$ = $e$@. + +Type Declarations and Type Aliases +---------------------------------- + +\label{sec:typedcl} +\label{sec:typealias} + +\todo{Higher-kinded tdecls should have a separate section} + +\syntax\begin{lstlisting} + Dcl ::= `type' {nl} TypeDcl + TypeDcl ::= id [TypeParamClause] [`>:' Type] [`<:' Type] + Def ::= type {nl} TypeDef + TypeDef ::= id [TypeParamClause] `=' Type +\end{lstlisting} + +%@M +A {\em type declaration} ~\lstinline@type $t$[$\tps\,$] >: $L$ <: $U$@~ declares +$t$ to be an abstract type with lower bound type $L$ and upper bound +type $U$. If the type parameter clause \lstinline@[$\tps\,$]@ is omitted, $t$ abstracts over a first-order type, otherwise $t$ stands for a type constructor that accepts type arguments as described by the type parameter clause. + +%@M +If a type declaration appears as a member declaration of a +type, implementations of the type may implement $t$ with any type $T$ +for which $L \conforms T \conforms U$. It is a compile-time error if +$L$ does not conform to $U$. Either or both bounds may be omitted. +If the lower bound $L$ is absent, the bottom type +\lstinline@scala.Nothing@ is assumed. If the upper bound $U$ is absent, +the top type \lstinline@scala.Any@ is assumed. + +%@M +A type constructor declaration imposes additional restrictions on the +concrete types for which $t$ may stand. Besides the bounds $L$ and +$U$, the type parameter clause may impose higher-order bounds and +variances, as governed by the conformance of type constructors +(\sref{sec:conformance}). + +%@M +The scope of a type parameter extends over the bounds ~\lstinline@>: $L$ <: $U$@ and the type parameter clause $\tps$ itself. A +higher-order type parameter clause (of an abstract type constructor +$tc$) has the same kind of scope, restricted to the declaration of the +type parameter $tc$. + +To illustrate nested scoping, these declarations are all equivalent: ~\lstinline@type t[m[x] <: Bound[x], Bound[x]]@, ~\lstinline@type t[m[x] <: Bound[x], Bound[y]]@ and ~\lstinline@type t[m[x] <: Bound[x], Bound[_]]@, as the scope of, e.g., the type parameter of $m$ is limited to the declaration of $m$. In all of them, $t$ is an abstract type member that abstracts over two type constructors: $m$ stands for a type constructor that takes one type parameter and that must be a subtype of $Bound$, $t$'s second type constructor parameter. ~\lstinline@t[MutableList, Iterable]@ is a valid use of $t$. + +A {\em type alias} ~\lstinline@type $t$ = $T$@~ defines $t$ to be an alias +name for the type $T$. The left hand side of a type alias may +have a type parameter clause, e.g. ~\lstinline@type $t$[$\tps\,$] = $T$@. The scope +of a type parameter extends over the right hand side $T$ and the +type parameter clause $\tps$ itself. + +The scope rules for definitions (\sref{sec:defs}) and type parameters +(\sref{sec:funsigs}) make it possible that a type name appears in its +own bound or in its right-hand side. However, it is a static error if +a type alias refers recursively to the defined type constructor itself. +That is, the type $T$ in a type alias ~\lstinline@type $t$[$\tps\,$] = $T$@~ may not +refer directly or indirectly to the name $t$. It is also an error if +an abstract type is directly or indirectly its own upper or lower bound. + +\example The following are legal type declarations and definitions: +\begin{lstlisting} +type IntList = List[Integer] +type T <: Comparable[T] +type Two[A] = Tuple2[A, A] +type MyCollection[+X] <: Iterable[X] +\end{lstlisting} + +The following are illegal: +\begin{lstlisting} +type Abs = Comparable[Abs] // recursive type alias + +type S <: T // S, T are bounded by themselves. +type T <: S + +type T >: Comparable[T.That] // Cannot select from T. + // T is a type, not a value +type MyCollection <: Iterable // Type constructor members must explicitly state their type parameters. +\end{lstlisting} + +If a type alias ~\lstinline@type $t$[$\tps\,$] = $S$@~ refers to a class type +$S$, the name $t$ can also be used as a constructor for +objects of type $S$. + +\example The \code{Predef} object contains a definition which establishes \code{Pair} +as an alias of the parameterized class \code{Tuple2}: +\begin{lstlisting} +type Pair[+A, +B] = Tuple2[A, B] +object Pair { + def apply[A, B](x: A, y: B) = Tuple2(x, y) + def unapply[A, B](x: Tuple2[A, B]): Option[Tuple2[A, B]] = Some(x) +} +\end{lstlisting} +As a consequence, for any two types $S$ and $T$, the type +~\lstinline@Pair[$S$, $T\,$]@~ is equivalent to the type ~\lstinline@Tuple2[$S$, $T\,$]@. +\code{Pair} can also be used as a constructor instead of \code{Tuple2}, as in: +\begin{lstlisting} +val x: Pair[Int, String] = new Pair(1, "abc") +\end{lstlisting} + +\section{Type Parameters}\label{sec:type-params} + +\syntax\begin{lstlisting} + TypeParamClause ::= `[' VariantTypeParam {`,' VariantTypeParam} `]' + VariantTypeParam ::= {Annotation} [`+' | `-'] TypeParam + TypeParam ::= (id | `_') [TypeParamClause] [`>:' Type] [`<:' Type] [`:' Type] +\end{lstlisting} + +Type parameters appear in type definitions, class definitions, and +function definitions. In this section we consider only type parameter +definitions with lower bounds ~\lstinline@>: $L$@~ and upper bounds +~\lstinline@<: $U$@~ whereas a discussion of context bounds +~\lstinline@: $U$@~ and view bounds ~\lstinline@<% $U$@~ +is deferred to Section~\ref{sec:context-bounds}. + +The most general form of a first-order type parameter is +~\lstinline!$@a_1\ldots@a_n$ $\pm$ $t$ >: $L$ <: $U$!. +Here, $L$, and $U$ are lower and upper bounds that +constrain possible type arguments for the parameter. It is a +compile-time error if $L$ does not conform to $U$. $\pm$ is a {\em +variance}, i.e.\ an optional prefix of either \lstinline@+@, or +\lstinline@-@. One or more annotations may precede the type parameter. + +\comment{ +The upper bound $U$ in a type parameter clauses may not be a final +class. The lower bound may not denote a value type.\todo{Why} +} + +\comment{@M TODO this is a pretty awkward description of scoping and distinctness of binders} +The names of all type parameters must be pairwise different in their enclosing type parameter clause. The scope of a type parameter includes in each case the whole type parameter clause. Therefore it is possible that a type parameter appears as part of its own bounds or the bounds of other type parameters in the same clause. However, a type parameter may not be bounded directly or indirectly by itself.\ + +A type constructor parameter adds a nested type parameter clause to the type parameter. The most general form of a type constructor parameter is ~\lstinline!$@a_1\ldots@a_n$ $\pm$ $t[\tps\,]$ >: $L$ <: $U$!. + +The above scoping restrictions are generalized to the case of nested type parameter clauses, which declare higher-order type parameters. Higher-order type parameters (the type parameters of a type parameter $t$) are only visible in their immediately surrounding parameter clause (possibly including clauses at a deeper nesting level) and in the bounds of $t$. Therefore, their names must only be pairwise different from the names of other visible parameters. Since the names of higher-order type parameters are thus often irrelevant, they may be denoted with a `\lstinline@_@', which is nowhere visible. + +\example Here are some well-formed type parameter clauses: +\begin{lstlisting} +[S, T] +[@specialized T, U] +[Ex <: Throwable] +[A <: Comparable[B], B <: A] +[A, B >: A, C >: A <: B] +[M[X], N[X]] +[M[_], N[_]] // equivalent to previous clause +[M[X <: Bound[X]], Bound[_]] +[M[+X] <: Iterable[X]] +\end{lstlisting} +The following type parameter clauses are illegal: +\begin{lstlisting} +[A >: A] // illegal, `A' has itself as bound +[A <: B, B <: C, C <: A] // illegal, `A' has itself as bound +[A, B, C >: A <: B] // illegal lower bound `A' of `C' does + // not conform to upper bound `B'. +\end{lstlisting} + +\section{Variance Annotations}\label{sec:variances} + +Variance annotations indicate how instances of parameterized types +vary with respect to subtyping (\sref{sec:conformance}). A +`\lstinline@+@' variance indicates a covariant dependency, a +`\lstinline@-@' variance indicates a contravariant dependency, and a +missing variance indication indicates an invariant dependency. + +%@M +A variance annotation constrains the way the annotated type variable +may appear in the type or class which binds the type parameter. In a +type definition ~\lstinline@type $T$[$\tps\,$] = $S$@, or a type +declaration ~\lstinline@type $T$[$\tps\,$] >: $L$ <: $U$@~ type parameters labeled +`\lstinline@+@' must only appear in covariant position whereas +type parameters labeled `\lstinline@-@' must only appear in contravariant +position. Analogously, for a class definition +~\lstinline@class $C$[$\tps\,$]($\ps\,$) extends $T$ { $x$: $S$ => ...}@, +type parameters labeled +`\lstinline@+@' must only appear in covariant position in the +self type $S$ and the template $T$, whereas type +parameters labeled `\lstinline@-@' must only appear in contravariant +position. + +The variance position of a type parameter in a type or template is +defined as follows. Let the opposite of covariance be contravariance, +and the opposite of invariance be itself. The top-level of the type +or template is always in covariant position. The variance position +changes at the following constructs. +\begin{itemize} +\item +The variance position of a method parameter is the opposite of the +variance position of the enclosing parameter clause. +\item +The variance position of a type parameter is the opposite of the +variance position of the enclosing type parameter clause. +\item +The variance position of the lower bound of a type declaration or type parameter +is the opposite of the variance position of the type declaration or parameter. +\item +The type of a mutable variable is always in invariant position. +\item +The prefix $S$ of a type selection \lstinline@$S$#$T$@ is always in invariant position. +\item +For a type argument $T$ of a type ~\lstinline@$S$[$\ldots T \ldots$ ]@: If the +corresponding type parameter is invariant, then $T$ is in +invariant position. If the corresponding type parameter is +contravariant, the variance position of $T$ is the opposite of +the variance position of the enclosing type ~\lstinline@$S$[$\ldots T \ldots$ ]@. +\end{itemize} +\todo{handle type aliases} +References to the type parameters in object-private values, variables, +or methods (\sref{sec:modifiers}) of the class are not checked for their variance +position. In these members the type parameter may appear anywhere +without restricting its legal variance annotations. + +\example The following variance annotation is legal. +\begin{lstlisting} +abstract class P[+A, +B] { + def fst: A; def snd: B +} +\end{lstlisting} +With this variance annotation, type instances +of $P$ subtype covariantly with respect to their arguments. +For instance, +\begin{lstlisting} +P[IOException, String] <: P[Throwable, AnyRef] . +\end{lstlisting} + +If the members of $P$ are mutable variables, +the same variance annotation becomes illegal. +\begin{lstlisting} +abstract class Q[+A, +B](x: A, y: B) { + var fst: A = x // **** error: illegal variance: + var snd: B = y // `A', `B' occur in invariant position. +} +\end{lstlisting} +If the mutable variables are object-private, the class definition +becomes legal again: +\begin{lstlisting} +abstract class R[+A, +B](x: A, y: B) { + private[this] var fst: A = x // OK + private[this] var snd: B = y // OK +} +\end{lstlisting} + +\example The following variance annotation is illegal, since $a$ appears +in contravariant position in the parameter of \code{append}: + +\begin{lstlisting} +abstract class Sequence[+A] { + def append(x: Sequence[A]): Sequence[A] + // **** error: illegal variance: + // `A' occurs in contravariant position. +} +\end{lstlisting} +The problem can be avoided by generalizing the type of \code{append} +by means of a lower bound: + +\begin{lstlisting} +abstract class Sequence[+A] { + def append[B >: A](x: Sequence[B]): Sequence[B] +} +\end{lstlisting} + +\example Here is a case where a contravariant type parameter is useful. + +\begin{lstlisting} +abstract class OutputChannel[-A] { + def write(x: A): Unit +} +\end{lstlisting} +With that annotation, we have that +\lstinline@OutputChannel[AnyRef]@ conforms to \lstinline@OutputChannel[String]@. +That is, a +channel on which one can write any object can substitute for a channel +on which one can write only strings. + +Function Declarations and Definitions +------------------------------------- + +\label{sec:funsigs} + +\syntax\begin{lstlisting} +Dcl ::= `def' FunDcl +FunDcl ::= FunSig `:' Type +Def ::= `def' FunDef +FunDef ::= FunSig [`:' Type] `=' Expr +FunSig ::= id [FunTypeParamClause] ParamClauses +FunTypeParamClause ::= `[' TypeParam {`,' TypeParam} `]' +ParamClauses ::= {ParamClause} [[nl] `(' `implicit' Params `)'] +ParamClause ::= [nl] `(' [Params] `)'} +Params ::= Param {`,' Param} +Param ::= {Annotation} id [`:' ParamType] [`=' Expr] +ParamType ::= Type + | `=>' Type + | Type `*' +\end{lstlisting} + +A function declaration has the form ~\lstinline@def $f\,\psig$: $T$@, where +$f$ is the function's name, $\psig$ is its parameter +signature and $T$ is its result type. A function definition +~\lstinline@def $f\,\psig$: $T$ = $e$@~ also includes a {\em function body} $e$, +i.e.\ an expression which defines the function's result. A parameter +signature consists of an optional type parameter clause \lstinline@[$\tps\,$]@, +followed by zero or more value parameter clauses +~\lstinline@($\ps_1$)$\ldots$($\ps_n$)@. Such a declaration or definition +introduces a value with a (possibly polymorphic) method type whose +parameter types and result type are as given. + +The type of the function body is expected to conform (\sref{sec:expr-typing}) +to the function's declared +result type, if one is given. If the function definition is not +recursive, the result type may be omitted, in which case it is +determined from the packed type of the function body. + +A type parameter clause $\tps$ consists of one or more type +declarations (\sref{sec:typedcl}), which introduce type parameters, +possibly with bounds. The scope of a type parameter includes +the whole signature, including any of the type parameter bounds as +well as the function body, if it is present. + +A value parameter clause $\ps$ consists of zero or more formal +parameter bindings such as \lstinline@$x$: $T$@ or \lstinline@$x: T = e$@, which bind value +parameters and associate them with their types. Each value parameter +declaration may optionally define a default argument. The default argument +expression $e$ is type-checked with an expected type $T'$ obtained +by replacing all occurences of the function's type parameters in $T$ by +the undefined type. + +For every parameter $p_{i,j}$ with a default argument a method named +\lstinline@$f\Dollar$default$\Dollar$n@ is generated which computes the default argument +expression. Here, $n$ denotes the parameter's position in the method +declaration. These methods are parametrized by the type parameter clause +\lstinline@[$\tps\,$]@ and all value parameter clauses +~\lstinline@($\ps_1$)$\ldots$($\ps_{i-1}$)@ preceeding $p_{i,j}$. +The \lstinline@$f\Dollar$default$\Dollar$n@ methods are inaccessible for +user programs. + +The scope of a formal value parameter name $x$ comprises all subsequent parameter +clauses, as well as the method return type and the function body, if +they are given.\footnote{However, at present singleton types of method +parameters may only appear in the method body; so {\em dependent method +types} are not supported.} Both type parameter names +and value parameter names must be pairwise distinct. + +\example In the method +\begin{lstlisting} +def compare[T](a: T = 0)(b: T = a) = (a == b) +\end{lstlisting} +the default expression \code{0} is type-checked with an undefined expected +type. When applying \code{compare()}, the default value \code{0} is inserted +and \code{T} is instantiated to \code{Int}. The methods computing the default +arguments have the form: +\begin{lstlisting} +def compare$\Dollar$default$\Dollar$1[T]: Int = 0 +def compare$\Dollar$default$\Dollar$2[T](a: T): T = a +\end{lstlisting} + +\subsection{By-Name Parameters}\label{sec:by-name-params} + +\syntax\begin{lstlisting} +ParamType ::= `=>' Type +\end{lstlisting} + +The type of a value parameter may be prefixed by \code{=>}, e.g.\ +~\lstinline@$x$: => $T$@. The type of such a parameter is then the +parameterless method type ~\lstinline@=> $T$@. This indicates that the +corresponding argument is not evaluated at the point of function +application, but instead is evaluated at each use within the +function. That is, the argument is evaluated using {\em call-by-name}. + +The by-name modifier is disallowed for parameters of classes that +carry a \code{val} or \code{var} prefix, including parameters of case +classes for which a \code{val} prefix is implicitly generated. The +by-name modifier is also disallowed for implicit parameters (\sref{sec:impl-params}). + +\example The declaration +\begin{lstlisting} +def whileLoop (cond: => Boolean) (stat: => Unit): Unit +\end{lstlisting} +indicates that both parameters of \code{whileLoop} are evaluated using +call-by-name. + +\subsection{Repeated Parameters}\label{sec:repeated-params} + +\syntax\begin{lstlisting} +ParamType ::= Type `*' +\end{lstlisting} + +The last value parameter of a parameter section may be suffixed by +``\code{*}'', e.g.\ ~\lstinline@(..., $x$:$T$*)@. The type of such a +{\em repeated} parameter inside the method is then the sequence type +\lstinline@scala.Seq[$T$]@. Methods with repeated parameters +\lstinline@$T$*@ take a variable number of arguments of type $T$. +That is, if a method $m$ with type ~\lstinline@($p_1:T_1 \commadots p_n:T_n, +p_s:S$*)$U$@~ is applied to arguments $(e_1 \commadots e_k)$ where $k \geq +n$, then $m$ is taken in that application to have type $(p_1:T_1 +\commadots p_n:T_n, p_s:S \commadots p_{s'}S)U$, with $k - n$ occurrences of type +$S$ where any parameter names beyond $p_s$ are fresh. The only exception to this rule is if the last argument is +marked to be a {\em sequence argument} via a \lstinline@_*@ type +annotation. If $m$ above is applied to arguments +~\lstinline@($e_1 \commadots e_n, e'$: _*)@, then the type of $m$ in +that application is taken to be +~\lstinline@($p_1:T_1\commadots p_n:T_n,p_{s}:$scala.Seq[$S$])@. + +It is not allowed to define any default arguments in a parameter section +with a repeated parameter. + +\example The following method definition computes the sum of the squares of a variable number +of integer arguments. +\begin{lstlisting} +def sum(args: Int*) = { + var result = 0 + for (arg <- args) result += arg * arg + result +} +\end{lstlisting} +The following applications of this method yield \code{0}, \code{1}, +\code{6}, in that order. +\begin{lstlisting} +sum() +sum(1) +sum(1, 2, 3) +\end{lstlisting} +Furthermore, assume the definition: +\begin{lstlisting} +val xs = List(1, 2, 3) +\end{lstlisting} +The following application of method \lstinline@sum@ is ill-formed: +\begin{lstlisting} +sum(xs) // ***** error: expected: Int, found: List[Int] +\end{lstlisting} +By contrast, the following application is well formed and yields again +the result \code{6}: +\begin{lstlisting} +sum(xs: _*) +\end{lstlisting} + +\subsection{Procedures}\label{sec:procedures} + +\syntax\begin{lstlisting} + FunDcl ::= FunSig + FunDef ::= FunSig [nl] `{' Block `}' +\end{lstlisting} + +Special syntax exists for procedures, i.e.\ functions that return the +\verb@Unit@ value \verb@{}@. +A procedure declaration is a function declaration where the result type +is omitted. The result type is then implicitly completed to the +\verb@Unit@ type. E.g., ~\lstinline@def $f$($\ps$)@~ is equivalent to +~\lstinline@def $f$($\ps$): Unit@. + +A procedure definition is a function definition where the result type +and the equals sign are omitted; its defining expression must be a block. +E.g., ~\lstinline@def $f$($\ps$) {$\stats$}@~ is equivalent to +~\lstinline@def $f$($\ps$): Unit = {$\stats$}@. + +\example Here is a declaration and a definition of a procedure named \lstinline@write@: +\begin{lstlisting} +trait Writer { + def write(str: String) +} +object Terminal extends Writer { + def write(str: String) { System.out.println(str) } +} +\end{lstlisting} +The code above is implicitly completed to the following code: +\begin{lstlisting} +trait Writer { + def write(str: String): Unit +} +object Terminal extends Writer { + def write(str: String): Unit = { System.out.println(str) } +} +\end{lstlisting} + +\subsection{Method Return Type Inference}\label{sec:meth-type-inf} + +\comment{ +Functions that are members of a class $C$ may define parameters +without type annotations. The types of such parameters are inferred as +follows. Say, a method $m$ in a class $C$ has a parameter $p$ which +does not have a type annotation. We first determine methods $m'$ in +$C$ that might be overridden (\sref{sec:overriding}) by $m$, assuming +that appropriate types are assigned to all parameters of $m$ whose +types are missing. If there is exactly one such method, the type of +the parameter corresponding to $p$ in that method -- seen as a member +of $C$ -- is assigned to $p$. It is a compile-time error if there are +several such overridden methods $m'$, or if there is none. +} + +A class member definition $m$ that overrides some other function $m'$ +in a base class of $C$ may leave out the return type, even if it is +recursive. In this case, the return type $R'$ of the overridden +function $m'$, seen as a member of $C$, is taken as the return type of +$m$ for each recursive invocation of $m$. That way, a type $R$ for the +right-hand side of $m$ can be determined, which is then taken as the +return type of $m$. Note that $R$ may be different from $R'$, as long +as $R$ conforms to $R'$. + +\comment{ +\example Assume the following definitions: +\begin{lstlisting} +trait I[A] { + def f(x: A)(y: A): A +} +class C extends I[Int] { + def f(x)(y) = x + y +} +\end{lstlisting} +Here, the parameter and return types of \lstinline@f@ in \lstinline@C@ are +inferred from the corresponding types of \lstinline@f@ in \lstinline@I@. The +signature of \lstinline@f@ in \lstinline@C@ is thus inferred to be +\begin{lstlisting} + def f(x: Int)(y: Int): Int +\end{lstlisting} +} + +\example Assume the following definitions: +\begin{lstlisting} +trait I { + def factorial(x: Int): Int +} +class C extends I { + def factorial(x: Int) = if (x == 0) 1 else x * factorial(x - 1) +} +\end{lstlisting} +Here, it is OK to leave out the result type of \lstinline@factorial@ +in \lstinline@C@, even though the method is recursive. + + +\comment{ +For any index $i$ let $\fsig_i$ be a function signature consisting of a function +name, an optional type parameter section, and zero or more parameter +sections. Then a function declaration +~\lstinline@def $\fsig_1 \commadots \fsig_n$: $T$@~ +is a shorthand for the sequence of function +declarations ~\lstinline@def $\fsig_1$: $T$; ...; def $\fsig_n$: $T$@. +A function definition ~\lstinline@def $\fsig_1 \commadots \fsig_n$ = $e$@~ is a +shorthand for the sequence of function definitions +~\lstinline@def $\fsig_1$ = $e$; ...; def $\fsig_n$ = $e$@. +A function definition +~\lstinline@def $\fsig_1 \commadots \fsig_n: T$ = $e$@~ is a shorthand for the +sequence of function definitions +~\lstinline@def $\fsig_1: T$ = $e$; ...; def $\fsig_n: T$ = $e$@. +} + +\comment{ +\section{Overloaded Definitions} +\label{sec:overloaded-defs} +\todo{change} + +An overloaded definition is a set of $n > 1$ value or function +definitions in the same statement sequence that define the same name, +binding it to types ~\lstinline@$T_1 \commadots T_n$@, respectively. +The individual definitions are called {\em alternatives}. Overloaded +definitions may only appear in the statement sequence of a template. +Alternatives always need to specify the type of the defined entity +completely. It is an error if the types of two alternatives $T_i$ and +$T_j$ have the same erasure (\sref{sec:erasure}). + +\todo{Say something about bridge methods.} +%This must be a well-formed +%overloaded type +} + +\section{Import Clauses} +\label{sec:import} + +\syntax\begin{lstlisting} + Import ::= `import' ImportExpr {`,' ImportExpr} + ImportExpr ::= StableId `.' (id | `_' | ImportSelectors) + ImportSelectors ::= `{' {ImportSelector `,'} + (ImportSelector | `_') `}' + ImportSelector ::= id [`=>' id | `=>' `_'] +\end{lstlisting} + +An import clause has the form ~\lstinline@import $p$.$I$@~ where $p$ is a stable +identifier (\sref{sec:paths}) and $I$ is an import expression. +The import expression determines a set of names of importable members of $p$ +which are made available without qualification. A member $m$ of $p$ is +{\em importable} if it is not object-private (\sref{sec:modifiers}). +The most general form of an import expression is a list of {\em import +selectors} +\begin{lstlisting} +{ $x_1$ => $y_1 \commadots x_n$ => $y_n$, _ } . +\end{lstlisting} +for $n \geq 0$, where the final wildcard `\lstinline@_@' may be absent. It +makes available each importable member \lstinline@$p$.$x_i$@ under the unqualified name +$y_i$. I.e.\ every import selector ~\lstinline@$x_i$ => $y_i$@~ renames +\lstinline@$p$.$x_i$@ to +$y_i$. If a final wildcard is present, all importable members $z$ of +$p$ other than ~\lstinline@$x_1 \commadots x_n,y_1 \commadots y_n$@~ are also made available +under their own unqualified names. + +Import selectors work in the same way for type and term members. For +instance, an import clause ~\lstinline@import $p$.{$x$ => $y\,$}@~ renames the term +name \lstinline@$p$.$x$@ to the term name $y$ and the type name \lstinline@$p$.$x$@ +to the type name $y$. At least one of these two names must +reference an importable member of $p$. + +If the target in an import selector is a wildcard, the import selector +hides access to the source member. For instance, the import selector +~\lstinline@$x$ => _@~ ``renames'' $x$ to the wildcard symbol (which is +unaccessible as a name in user programs), and thereby effectively +prevents unqualified access to $x$. This is useful if there is a +final wildcard in the same import selector list, which imports all +members not mentioned in previous import selectors. + +The scope of a binding introduced by an import-clause starts +immediately after the import clause and extends to the end of the +enclosing block, template, package clause, or compilation unit, +whichever comes first. + +Several shorthands exist. An import selector may be just a simple name +$x$. In this case, $x$ is imported without renaming, so the +import selector is equivalent to ~\lstinline@$x$ => $x$@. Furthermore, it is +possible to replace the whole import selector list by a single +identifier or wildcard. The import clause ~\lstinline@import $p$.$x$@~ is +equivalent to ~\lstinline@import $p$.{$x\,$}@~, i.e.\ it makes available without +qualification the member $x$ of $p$. The import clause +~\lstinline@import $p$._@~ is equivalent to +~\lstinline@import $p$.{_}@, +i.e.\ it makes available without qualification all members of $p$ +(this is analogous to ~\lstinline@import $p$.*@~ in Java). + +An import clause with multiple import expressions +~\lstinline@import $p_1$.$I_1 \commadots p_n$.$I_n$@~ is interpreted as a +sequence of import clauses +~\lstinline@import $p_1$.$I_1$; $\ldots$; import $p_n$.$I_n$@. + +\example Consider the object definition: +\begin{lstlisting} +object M { + def z = 0, one = 1 + def add(x: Int, y: Int): Int = x + y +} +\end{lstlisting} +Then the block +\begin{lstlisting} +{ import M.{one, z => zero, _}; add(zero, one) } +\end{lstlisting} +is equivalent to the block +\begin{lstlisting} +{ M.add(M.z, M.one) } . +\end{lstlisting} + diff --git a/07-classes-and-objects.md b/07-classes-and-objects.md new file mode 100644 index 000000000000..ab274ffa47b2 --- /dev/null +++ b/07-classes-and-objects.md @@ -0,0 +1,1222 @@ +Classes and Objects +=================== + + +\syntax\begin{lstlisting} + TmplDef ::= [`case'] `class' ClassDef + | [`case'] `object' ObjectDef + | `trait' TraitDef +\end{lstlisting} + +Classes (\sref{sec:class-defs}) and objects +(\sref{sec:object-defs}) are both defined in terms of {\em templates}. + +\section{Templates} +\label{sec:templates} + +\syntax\begin{lstlisting} + ClassTemplate ::= [EarlyDefs] ClassParents [TemplateBody] + TraitTemplate ::= [EarlyDefs] TraitParents [TemplateBody] + ClassParents ::= Constr {`with' AnnotType} + TraitParents ::= AnnotType {`with' AnnotType} + TemplateBody ::= [nl] `{' [SelfType] TemplateStat {semi TemplateStat} `}' + SelfType ::= id [`:' Type] `=>' + | this `:' Type `=>' +\end{lstlisting} + +A template defines the type signature, behavior and initial state of a +trait or class of objects or of a single object. Templates form part of +instance creation expressions, class definitions, and object +definitions. A template +~\lstinline@$sc$ with $mt_1$ with $\ldots$ with $mt_n$ {$\stats\,$}@~ +consists of a constructor invocation $sc$ +which defines the template's {\em superclass}, trait references +~\lstinline@$mt_1 \commadots mt_n$@~ $(n \geq 0)$, which define the +template's {\em traits}, and a statement sequence $\stats$ which +contains initialization code and additional member definitions for the +template. + +Each trait reference $mt_i$ must denote a trait (\sref{sec:traits}). +By contrast, the superclass constructor $sc$ normally refers to a +class which is not a trait. It is possible to write a list of +parents that starts with a trait reference, e.g. +~\lstinline@$mt_1$ with $\ldots$ with $mt_n$@. In that case the list +of parents is implicitly extended to include the supertype of $mt_1$ +as first parent type. The new supertype must have at least one +constructor that does not take parameters. In the following, we will +always assume that this implicit extension has been performed, so that +the first parent class of a template is a regular superclass +constructor, not a trait reference. + +The list of parents of every class is also always implicitly extended +by a reference to the \code{scala.ScalaObject} trait as last +mixin. E.g.\ +\begin{lstlisting} +$sc$ with $mt_1$ with $\ldots$ with $mt_n$ {$\stats\,$} +\end{lstlisting} +becomes +\begin{lstlisting} +$mt_1$ with $\ldots$ with $mt_n$ with ScalaObject {$\stats\,$}. +\end{lstlisting} + +The list of parents of a template must be well-formed. This means that +the class denoted by the superclass constructor $sc$ must be a +subclass of the superclasses of all the traits $mt_1 \commadots mt_n$. +In other words, the non-trait classes inherited by a template form a +chain in the inheritance hierarchy which starts with the template's +superclass. + +The {\em least proper supertype} of a template is the class type or +compound type (\sref{sec:compound-types}) consisting of all its parent +class types. + +The statement sequence $\stats$ contains member definitions that +define new members or overwrite members in the parent classes. If the +template forms part of an abstract class or trait definition, the +statement part $\stats$ may also contain declarations of abstract +members. If the template forms part of a concrete class definition, +$\stats$ may still contain declarations of abstract type members, but +not of abstract term members. Furthermore, $\stats$ may in any case +also contain expressions; these are executed in the order they are +given as part of the initialization of a template. + +The sequence of template statements may be prefixed with a formal +parameter definition and an arrow, e.g.\ \lstinline@$x$ =>@, or +~\lstinline@$x$:$T$ =>@. If a formal parameter is given, it can be +used as an alias for the reference \lstinline@this@ throughout the +body of the template. +If the formal parameter comes with a type $T$, this definition affects +the {\em self type} $S$ of the underlying class or object as follows: Let $C$ be the type +of the class or trait or object defining the template. +If a type $T$ is given for the formal self parameter, $S$ +is the greatest lower bound of $T$ and $C$. +If no type $T$ is given, $S$ is just $C$. +Inside the template, the type of \code{this} is assumed to be $S$. + +The self type of a class or object must conform to the self types of +all classes which are inherited by the template $t$. + +A second form of self type annotation reads just +~\lstinline@this: $S$ =>@. It prescribes the type $S$ for \lstinline@this@ +without introducing an alias name for it. + +\example Consider the following class definitions: + +\begin{lstlisting} +class Base extends Object {} +trait Mixin extends Base {} +object O extends Mixin {} +\end{lstlisting} +In this case, the definition of \code{O} is expanded to: +\begin{lstlisting} +object O extends Base with Mixin {} +\end{lstlisting} + +%The type of each non-private definition or declaration of a +%template must be equivalent to a type which does not refer to any +%private members of that template. + +\todo{Make all references to Java generic} + +\paragraph{\em Inheriting from Java Types} A template may have a Java class as +its superclass and Java interfaces as its mixins. + +\paragraph{\em Template Evaluation} +Consider a template ~\lstinline@$sc$ with $mt_1$ with $mt_n$ {$\stats\,$}@. + +If this is the template of a trait (\sref{sec:traits}) then its {\em +mixin-evaluation} consists of an evaluation of the statement sequence +$\stats$. + +If this is not a template of a trait, then its {\em evaluation} +consists of the following steps. +\begin{itemize} +\item +First, the superclass constructor $sc$ is evaluated (\sref{sec:constr-invoke}). +\item +Then, all base classes in the template's linearization +(\sref{sec:linearization}) up to the +template's superclass denoted by $sc$ are +mixin-evaluated. Mixin-evaluation happens in reverse order of +occurrence in the linearization. +\item +Finally the statement sequence $\stats\,$ is evaluated. +\end{itemize} + +\paragraph{\em Delayed Initializaton} +The initialization code of an object or class (but not a trait) that follows the superclass +constructor invocation and the mixin-evaluation of the template's base +classes is passed to a special hook, which is inaccessible from user +code. Normally, that hook simply executes the code that is passed to +it. But templates inheriting the \lstinline@scala.DelayedInit@ trait +can override the hook by re-implementing the \lstinline@delayedInit@ +method, which is defined as follows: + +\begin{lstlisting} + def delayedInit(body: => Unit) +\end{lstlisting} + + +\subsection{Constructor Invocations} +\label{sec:constr-invoke} +\syntax\begin{lstlisting} + Constr ::= AnnotType {`(' [Exprs] `)'} +\end{lstlisting} + +Constructor invocations define the type, members, and initial state of +objects created by an instance creation expression, or of parts of an +object's definition which are inherited by a class or object +definition. A constructor invocation is a function application +~\lstinline@$x$.$c$[$\targs$]($\args_1$)$\ldots$($\args_n$)@, where $x$ is a stable identifier +(\sref{sec:stable-ids}), $c$ is a type name which either designates a +class or defines an alias type for one, $\targs$ is a type argument +list, $\args_1 \commadots \args_n$ are argument lists, and there is a +constructor of that class which is applicable (\sref{sec:apply}) +to the given arguments. If the constructor invocation uses named or +default arguments, it is transformed into a block expression using the +same transformation as described in (\sref{sec:named-default}). + +The prefix `\lstinline@$x$.@' can be omitted. A type argument list +can be given only if the class $c$ takes type parameters. Even then +it can be omitted, in which case a type argument list is synthesized +using local type inference (\sref{sec:local-type-inf}). If no explicit +arguments are given, an empty list \lstinline@()@ is implicitly supplied. + +An evaluation of a constructor invocation +~\lstinline@$x$.$c$[$\targs$]($\args_1$)$\ldots$($\args_n$)@~ +consists of the following steps: +\begin{itemize} +\item First, the prefix $x$ is evaluated. +\item Then, the arguments $\args_1 \commadots \args_n$ are evaluated from left to right. +\item Finally, the class being constructed is initialized by evaluating the + template of the class referred to by $c$. +\end{itemize} + +\subsection{Class Linearization}\label{sec:linearization} + +The classes reachable through transitive closure of the direct +inheritance relation from a class $C$ are called the {\em +base classes} of $C$. Because of mixins, the inheritance relationship +on base classes forms in general a directed acyclic graph. A +linearization of this graph is defined as follows. + +\newcommand{\uright}{\;\vec +\;} +\newcommand{\lin}[1]{{\cal L}(#1)} + +\begin{definition}\label{def:lin} Let $C$ be a class with template +~\lstinline@$C_1$ with ... with $C_n$ { $\stats$ }@. +The {\em linearization} of $C$, $\lin C$ is defined as follows: +\bda{rcl} +\lin C &=& C\ , \ \lin{C_n} \uright \ldots \uright \lin{C_1} +\eda +Here $\uright$ denotes concatenation where elements of the right operand +replace identical elements of the left operand: +\bda{lcll} +\{a, A\} \uright B &=& a, (A \uright B) &{\bf if} a \not\in B \\ + &=& A \uright B &{\bf if} a \in B +\eda +\end{definition} + +\example Consider the following class definitions. +\begin{lstlisting} +abstract class AbsIterator extends AnyRef { ... } +trait RichIterator extends AbsIterator { ... } +class StringIterator extends AbsIterator { ... } +class Iter extends StringIterator with RichIterator { ... } +\end{lstlisting} +Then the linearization of class \lstinline@Iter@ is +\begin{lstlisting} +{ Iter, RichIterator, StringIterator, AbsIterator, ScalaObject, AnyRef, Any } +\end{lstlisting} +Trait \lstinline@ScalaObject@ appears in this list because it +is added as last mixin to every Scala class (\sref{sec:templates}). + +Note that the linearization of a class refines the inheritance +relation: if $C$ is a subclass of $D$, then $C$ precedes $D$ in any +linearization where both $C$ and $D$ occur. +\ref{def:lin} also satisfies the property that a linearization +of a class always contains the linearization of its direct superclass +as a suffix. For instance, the linearization of +\lstinline@StringIterator@ is +\begin{lstlisting} +{ StringIterator, AbsIterator, ScalaObject, AnyRef, Any } +\end{lstlisting} +which is a suffix of the linearization of its subclass \lstinline@Iter@. +The same is not true for the linearization of mixins. +For instance, the linearization of \lstinline@RichIterator@ is +\begin{lstlisting} +{ RichIterator, AbsIterator, ScalaObject, AnyRef, Any } +\end{lstlisting} +which is not a suffix of the linearization of \lstinline@Iter@. + + +\subsection{Class Members} +\label{sec:members} + +A class $C$ defined by a template +~\lstinline@$C_1$ with $\ldots$ with $C_n$ { $\stats$ }@~ +can define members in its statement sequence +$\stats$ and can inherit members from all parent classes. Scala +adopts Java and C\#'s conventions for static overloading of +methods. It is thus possible that a class defines and/or inherits +several methods with the same name. To decide whether a defined +member of a class $C$ overrides a member of a parent class, or whether +the two co-exist as overloaded variants in $C$, Scala uses the +following definition of {\em matching} on members: + +\begin{definition} +A member definition $M$ {\em matches} a member definition $M'$, if $M$ +and $M'$ bind the same name, and one of following holds. +\begin{enumerate} +\item Neither $M$ nor $M'$ is a method definition. +\item $M$ and $M'$ define both monomorphic methods with equivalent argument + types. +\item $M$ defines a parameterless method and $M'$ defines a method + with an empty parameter list \code{()} or {\em vice versa}. +\item $M$ and $M'$ define both polymorphic methods with +equal number of argument types $\overline T$, $\overline T'$ +and equal numbers of type parameters +$\overline t$, $\overline t'$, say, and $\overline T' = [\overline t'/\overline t]\overline T$. +%every argument type +%$T_i$ of $M$ is equal to the corresponding argument type $T'_i$ of +%$M'$ where every occurrence of a type parameter $t'$ of $M'$ has been replaced by the corresponding type parameter $t$ of $M$. +\end{enumerate} +\end{definition} +Member definitions fall into two categories: concrete and abstract. +Members of class $C$ are either {\em directly defined} (i.e.\ they appear in +$C$'s statement sequence $\stats$) or they are {\em inherited}. There are two rules +that determine the set of members of a class, one for each category: + +\begin{definition}\label{def:member} +A {\em concrete member} of a class $C$ is any concrete definition $M$ in +some class $C_i \in \lin C$, except if there is a preceding class $C_j +\in \lin C$ where $j < i$ which directly defines a concrete member $M'$ matching $M$. + +An {\em abstract member} of a class $C$ is any abstract definition $M$ +in some class $C_i \in \lin C$, except if $C$ contains already a +concrete member $M'$ matching $M$, or if there is a preceding class +$C_j \in \lin C$ where $j < i$ which directly defines an abstract member $M'$ matching +$M$. +\end{definition} +This definition also determines the overriding relationships between +matching members of a class $C$ and its parents (\sref{sec:overriding}). +First, a concrete definition always overrides an abstract definition. Second, for +definitions $M$ and $M$' which are both concrete or both abstract, $M$ +overrides $M'$ if $M$ appears in a class that precedes (in the +linearization of $C$) the class in which $M'$ is defined. + +It is an error if a template directly defines two matching members. It +is also an error if a template contains two members (directly defined +or inherited) with the same name and the same erased type (\sref{sec:erasure}). +Finally, a template is not allowed to contain two methods (directly +defined or inherited) with the same name which both define default arguments. + + +\comment{ +The type of a member $m$ is determined as follows: If $m$ is defined +in $\stats$, then its type is the type as given in the member's +declaration or definition. Otherwise, if $m$ is inherited from the +base class ~\lstinline@$B$[$T_1$, $\ldots$. $T_n$]@, $B$'s class declaration has formal +parameters ~\lstinline@[$a_1 \commadots a_n$]@, and $M$'s type in $B$ is $U$, then +$M$'s type in $C$ is ~\lstinline@$U$[$a_1$ := $T_1 \commadots a_n$ := $T_n$]@. + +\ifqualified{ +Members of templates have internally qualified names $Q\qex x$ where +$x$ is a simple name and $Q$ is either the empty name $\epsilon$, or +is a qualified name referencing the module or class that first +introduces the member. A basic declaration or definition of $x$ in a +module or class $M$ introduces a member with the following qualified +name: +\begin{enumerate} +\item +If the binding is labeled with an ~\lstinline@override $Q$@\notyet{Override + with qualifier} modifier, +where $Q$ is a fully qualified name of a base class of $M$, then the +qualified name is the qualified expansion (\sref{sec:names}) of $x$ in +$Q$. +\item +If the binding is labeled with an \code{override} modifier without a +base class name, then the qualified name is the qualified expansion +of $x$ in $M$'s least proper supertype (\sref{sec:templates}). +\item +An implicit \code{override} modifier is added and case (2) also +applies if $M$'s least proper supertype contains an abstract member +with simple name $x$. +\item +If no \code{override} modifier is given or implied, then if $M$ is +labeled \code{qualified}, the qualified name is $M\qex x$. If $M$ is +not labeled \code{qualified}, the qualified name is $\epsilon\qex x$. +\end{enumerate} +} +} + +\example Consider the trait definitions: + +\begin{lstlisting} +trait A { def f: Int } +trait B extends A { def f: Int = 1 ; def g: Int = 2 ; def h: Int = 3 } +trait C extends A { override def f: Int = 4 ; def g: Int } +trait D extends B with C { def h: Int } +\end{lstlisting} + +Then trait \code{D} has a directly defined abstract member \code{h}. It +inherits member \code{f} from trait \code{C} and member \code{g} from +trait \code{B}. + +\subsection{Overriding} +\label{sec:overriding} + +\todo{Explain that classes cannot override each other} + +A member $M$ of class $C$ that matches (\sref{sec:members}) +a non-private member $M'$ of a +base class of $C$ is said to {\em override} that member. In this case +the binding of the overriding member $M$ must subsume +(\sref{sec:conformance}) the binding of the overridden member $M'$. +Furthermore, the following restrictions on modifiers apply to $M$ and +$M'$: +\begin{itemize} +\item +$M'$ must not be labeled \code{final}. +\item +$M$ must not be \code{private} (\sref{sec:modifiers}). +\item +If $M$ is labeled ~\lstinline@private[$C$]@~ for some enclosing class or package $C$, +then $M'$ must be labeled ~\lstinline@private[$C'$]@~ for some class or package $C'$ where +$C'$ equals $C$ or $C'$ is contained in $C$. \todo{check whether this is accurate} +\item +If $M$ is labeled \code{protected}, then $M'$ must also be +labeled \code{protected}. +\item +If $M'$ is not an abstract member, then +$M$ must be labeled \code{override}. +Furthermore, one of two possibilities must hold: +\begin{itemize} +\item either $M$ is defined in a subclass of the class where is $M'$ is defined, +\item or both $M$ and $M'$ override a third member $M''$ which is defined + in a base class of both the classes containing $M$ and $M'$ +\end{itemize} +\item +If $M'$ is incomplete (\sref{sec:modifiers}) in $C$ then $M$ must be +labeled \code{abstract override}. +\item +If $M$ and $M'$ are both concrete value definitions, then either none +of them is marked \code{lazy} or both must be marked \code{lazy}. +\end{itemize} +A special rule concerns parameterless methods. If a paramterless +method defined as \lstinline@def $f$: $T$ = ...@ or +\lstinline@def $f$ = ...@ overrides a method of +type $()T'$ which has an empty parameter list, then $f$ is also +assumed to have an empty parameter list. + +Another restriction applies to abstract type members: An abstract type +member with a volatile type (\sref{sec:volatile-types}) as its upper +bound may not override an abstract type member which does not have a +volatile upper bound. + +An overriding method inherits all default arguments from the definition +in the superclass. By specifying default arguments in the overriding method +it is possible to add new defaults (if the corresponding parameter in the +superclass does not have a default) or to override the defaults of the +superclass (otherwise). + +\example\label{ex:compound-a} +Consider the definitions: +\begin{lstlisting} +trait Root { type T <: Root } +trait A extends Root { type T <: A } +trait B extends Root { type T <: B } +trait C extends A with B +\end{lstlisting} +Then the class definition \code{C} is not well-formed because the +binding of \code{T} in \code{C} is +~\lstinline@type T <: B@, +which fails to subsume the binding ~\lstinline@type T <: A@~ of \code{T} +in type \code{A}. The problem can be solved by adding an overriding +definition of type \code{T} in class \code{C}: +\begin{lstlisting} +class C extends A with B { type T <: C } +\end{lstlisting} + +\subsection{Inheritance Closure}\label{sec:inheritance-closure} + +Let $C$ be a class type. The {\em inheritance closure} of $C$ is the +smallest set $\SS$ of types such that +\begin{itemize} +\item +If $T$ is in $\SS$, then every type $T'$ which forms syntactically +a part of $T$ is also in $\SS$. +\item +If $T$ is a class type in $\SS$, then all parents (\sref{sec:templates}) +of $T$ are also in $\SS$. +\end{itemize} +It is a static error if the inheritance closure of a class type +consists of an infinite number of types. (This restriction is +necessary to make subtyping decidable +\cite{kennedy-pierce:decidable}). + +\subsection{Early Definitions}\label{sec:early-defs} + +\syntax\begin{lstlisting} + EarlyDefs ::= `{' [EarlyDef {semi EarlyDef}] `}' `with' + EarlyDef ::= {Annotation} {Modifier} PatVarDef +\end{lstlisting} + +A template may start with an {\em early field definition} clause, +which serves to define certain field values before the supertype +constructor is called. In a template +\begin{lstlisting} +{ val $p_1$: $T_1$ = $e_1$ + ... + val $p_n$: $T_n$ = $e_n$ +} with $sc$ with $mt_1$ with $mt_n$ {$\stats\,$} +\end{lstlisting} +The initial pattern definitions of $p_1 \commadots p_n$ are called +{\em early definitions}. They define fields +which form part of the template. Every early definition must define +at least one variable. + +An early definition is type-checked and evaluated in the scope which +is in effect just before the template being defined, augmented by any +type parameters of the enclosing class and by any early definitions +preceding the one being defined. In particular, any reference to +\lstinline@this@ in the right-hand side of an early definition refers +to the identity of \lstinline@this@ just outside the template. Consequently, it +is impossible that an early definition refers to the object being +constructed by the template, or refers to one of its fields and +methods, except for any other preceding early definition in the same +section. Furthermore, references to preceding early definitions +always refer to the value that's defined there, and do not take into account +overriding definitions. In other words, a block of early definitions +is evaluated exactly as if it was a local bock containing a number of value +definitions. + + +Early definitions are evaluated in the order they are being defined +before the superclass constructor of the template is called. + +\example Early definitions are particularly useful for +traits, which do not have normal constructor parameters. Example: +\begin{lstlisting} +trait Greeting { + val name: String + val msg = "How are you, "+name +} +class C extends { + val name = "Bob" +} with Greeting { + println(msg) +} +\end{lstlisting} +In the code above, the field \code{name} is initialized before the +constructor of \code{Greeting} is called. Therefore, field \lstinline@msg@ in +class \code{Greeting} is properly initialized to \code{"How are you, Bob"}. + +If \code{name} had been initialized instead in \code{C}'s normal class +body, it would be initialized after the constructor of +\code{Greeting}. In that case, \lstinline@msg@ would be initialized to +\code{"How are you, "}. + + +\section{Modifiers} +\label{sec:modifiers} + +\syntax\begin{lstlisting} + Modifier ::= LocalModifier + | AccessModifier + | `override' + LocalModifier ::= `abstract' + | `final' + | `sealed' + | `implicit' + | `lazy' + AccessModifier ::= (`private' | `protected') [AccessQualifier] + AccessQualifier ::= `[' (id | `this') `]' +\end{lstlisting} + +Member definitions may be preceded by modifiers which affect the +accessibility and usage of the identifiers bound by them. If several +modifiers are given, their order does not matter, but the same +modifier may not occur more than once. Modifiers preceding a repeated +definition apply to all constituent definitions. The rules governing +the validity and meaning of a modifier are as follows. +\begin{itemize} +\item +The \code{private} modifier can be used with any definition or +declaration in a template. Such members can be accessed only from +within the directly enclosing template and its companion module or +companion class (\sref{def:companion}). They +are not inherited by subclasses and they may not override definitions +in parent classes. + +The modifier can be {\em qualified} with an identifier $C$ (e.g. +~\lstinline@private[$C$]@) that must denote a class or package +enclosing the definition. Members labeled with such a modifier are +accessible respectively only from code inside the package $C$ or only +from code inside the class $C$ and its companion module +(\sref{sec:object-defs}). Such members are also inherited only from +templates inside $C$. + +An different form of qualification is \code{private[this]}. A member +$M$ marked with this modifier can be accessed only from within +the object in which it is defined. That is, a selection $p.M$ is only +legal if the prefix is \code{this} or \lstinline@$O$.this@, for some +class $O$ enclosing the reference. In addition, the restrictions for +unqualified \code{private} apply. + +Members marked private without a qualifier are called {\em +class-private}, whereas members labeled with \lstinline@private[this]@ +are called {\em object-private}. A member {\em is private} if it is +either class-private or object-private, but not if it is marked +\lstinline@private[$C$]@ where $C$ is an identifier; in the latter +case the member is called {\em qualified private}. + +Class-private or object-private members may not be abstract, and may +not have \code{protected} or \code{override} modifiers. +\item +The \code{protected} modifier applies to class member definitions. +Protected members of a class can be accessed from within +\begin{itemize} +\item the template of the defining class, +\item all templates that have the defining class as a base class, +\item the companion module of any of those classes. +\end{itemize} +A \code{protected} modifier can be qualified with an +identifier $C$ (e.g. ~\lstinline@protected[$C$]@) that must denote a +class or package enclosing the definition. Members labeled with such +a modifier are also accessible respectively from all code inside the +package $C$ or from all code inside the class $C$ and its companion +module (\sref{sec:object-defs}). + +A protected identifier $x$ may be used as a member name in a selection +\lstinline@$r$.$x$@ only if one of the following applies: +\begin{itemize} +\item The access is within the template defining the member, or, if + a qualification $C$ is given, inside the package $C$, + or the class $C$, or its companion module, or +\item $r$ is one of the reserved words \code{this} and + \code{super}, or +\item $r$'s type conforms to a type-instance of the + class which contains the access. +\end{itemize} + +A different form of qualification is \code{protected[this]}. A member +$M$ marked with this modifier can be accessed only from within +the object in which it is defined. That is, a selection $p.M$ is only +legal if the prefix is \code{this} or \lstinline@$O$.this@, for some +class $O$ enclosing the reference. In addition, the restrictions for +unqualified \code{protected} apply. + +\item +The \code{override} modifier applies to class member definitions or declarations. It +is mandatory for member definitions or declarations that override some other concrete +member definition in a parent class. If an \code{override} +modifier is given, there must be at least one overridden member +definition or declaration (either concrete or abstract). +\item +The \code{override} modifier has an additional significance when +combined with the \code{abstract} modifier. That modifier combination +is only allowed for value members of traits. + +We call a member $M$ of a template {\em incomplete} if it is either +abstract (i.e.\ defined by a declaration), or it is labeled +\code{abstract} and \code{override} and +every member overridden by $M$ is again incomplete. + +Note that the \code{abstract override} modifier combination does not +influence the concept whether a member is concrete or abstract. A +member is {\em abstract} if only a declaration is given for it; it is +{\em concrete} if a full definition is given. +\item +The \code{abstract} modifier is used in class definitions. It is +redundant for traits, and mandatory for all other classes which have +incomplete members. Abstract classes cannot be instantiated +(\sref{sec:inst-creation}) with a constructor invocation unless +followed by mixins and/or a refinement which override all +incomplete members of the class. Only abstract classes and traits can have +abstract term members. + +The \code{abstract} modifier can also be used in conjunction with +\code{override} for class member definitions. In that case the +previous discussion applies. +\item +The \code{final} modifier applies to class member definitions and to +class definitions. A \code{final} class member definition may not be +overridden in subclasses. A \code{final} class may not be inherited by +a template. \code{final} is redundant for object definitions. Members +of final classes or objects are implicitly also final, so the +\code{final} modifier is generally redundant for them, too. Note, however, that +constant value definitions (\sref{sec:valdef}) do require an explicit \code{final} modifier, +even if they are defined in a final class or object. +\code{final} may +not be applied to incomplete members, and it may not be combined in one +modifier list with \code{sealed}. +\item +The \code{sealed} modifier applies to class definitions. A +\code{sealed} class may not be directly inherited, except if the inheriting +template is defined in the same source file as the inherited class. +However, subclasses of a sealed class can be inherited anywhere. +\item +The \code{lazy} modifier applies to value definitions. A \code{lazy} +value is initialized the first time it is accessed (which might never +happen at all). Attempting to access a lazy value during its +initialization might lead to looping behavior. If an exception is +thrown during initialization, the value is considered uninitialized, +and a later access will retry to evaluate its right hand side. +\end{itemize} + +\example The following code illustrates the use of qualified private: +\begin{lstlisting} +package outerpkg.innerpkg +class Outer { + class Inner { + private[Outer] def f() + private[innerpkg] def g() + private[outerpkg] def h() + } +} +\end{lstlisting} +Here, accesses to the method \lstinline@f@ can appear anywhere within +\lstinline@OuterClass@, but not outside it. Accesses to method +\lstinline@g@ can appear anywhere within the package +\lstinline@outerpkg.innerpkg@, as would be the case for +package-private methods in Java. Finally, accesses to method +\lstinline@h@ can appear anywhere within package \lstinline@outerpkg@, +including packages contained in it. + +\example A useful idiom to prevent clients of a class from +constructing new instances of that class is to declare the class +\code{abstract} and \code{sealed}: + +\begin{lstlisting} +object m { + abstract sealed class C (x: Int) { + def nextC = new C(x + 1) {} + } + val empty = new C(0) {} +} +\end{lstlisting} +For instance, in the code above clients can create instances of class +\lstinline@m.C@ only by calling the \code{nextC} method of an existing \lstinline@m.C@ +object; it is not possible for clients to create objects of class +\lstinline@m.C@ directly. Indeed the following two lines are both in error: + +\begin{lstlisting} + new m.C(0) // **** error: C is abstract, so it cannot be instantiated. + new m.C(0) {} // **** error: illegal inheritance from sealed class. +\end{lstlisting} + +A similar access restriction can be achieved by marking the primary +constructor \code{private} (see \ref{ex:private-constr}). + +\section{Class Definitions} +\label{sec:class-defs} + +\syntax\begin{lstlisting} + TmplDef ::= `class' ClassDef + ClassDef ::= id [TypeParamClause] {Annotation} + [AccessModifier] ClassParamClauses ClassTemplateOpt + ClassParamClauses ::= {ClassParamClause} + [[nl] `(' implicit ClassParams `)'] + ClassParamClause ::= [nl] `(' [ClassParams] ')' + ClassParams ::= ClassParam {`,' ClassParam} + ClassParam ::= {Annotation} [{Modifier} (`val' | `var')] + id [`:' ParamType] [`=' Expr] + ClassTemplateOpt ::= `extends' ClassTemplate | [[`extends'] TemplateBody] +\end{lstlisting} + +The most general form of class definition is +\begin{lstlisting} +class $c$[$\tps\,$] $as$ $m$($\ps_1$)$\ldots$($\ps_n$) extends $t$ $\gap(n \geq 0)$. +\end{lstlisting} +Here, +\begin{itemize} +\item[] +$c$ is the name of the class to be defined. +\item[] $\tps$ is a non-empty list of type parameters of the class +being defined. The scope of a type parameter is the whole class +definition including the type parameter section itself. It is +illegal to define two type parameters with the same name. The type +parameter section \lstinline@[$\tps\,$]@ may be omitted. A class with a type +parameter section is called {\em polymorphic}, otherwise it is called +{\em monomorphic}. +\item[] $as$ is a possibly empty sequence of annotations + (\sref{sec:annotations}). If any annotations are given, +they apply to the primary constructor of the class. +\item[] $m$ is an access modifier (\sref{sec:modifiers}) such as +\code{private} or \code{protected}, possibly with a qualification. If +such an access modifier is given it applies to the primary constructor +to the class. +\item[] +$(\ps_1)\ldots(\ps_n)$ are formal value parameter clauses for the {\em primary +constructor} of the class. The scope of a formal value parameter includes +all subsequent parameter sections and the template $t$. However, a formal value +parameter may not form +part of the types of any of the parent classes or members of the class +template $t$. +It is illegal to define two formal value parameters with the same name. +If no formal parameter sections are given, +an empty parameter section \lstinline@()@ is assumed. + +If a formal parameter declaration $x: T$ is preceded by a \code{val} +or \code{var} keyword, an accessor (getter) definition +(\sref{sec:vardef}) for this parameter is implicitly added to the +class. The getter introduces a value member $x$ of class $c$ that is +defined as an alias of the parameter. If the introducing keyword is +\code{var}, a setter accessor \lstinline@$x$_=@ (\sref{sec:vardef}) is also +implicitly added to the class. In invocation of that setter \lstinline@$x$_=($e$)@ +changes the value of the parameter to the result of evaluating $e$. +The formal parameter declaration may contain modifiers, which then +carry over to the accessor definition(s). A formal parameter prefixed +by \code{val} or \code{var} may not at the same time be a call-by-name +parameter (\sref{sec:by-name-params}). +\item[] +$t$ is a +template (\sref{sec:templates}) of the form +\begin{lstlisting} +$sc$ with $mt_1$ with $\ldots$ with $mt_m$ { $\stats$ } $\gap(m \geq 0)$ +\end{lstlisting} +which defines the base classes, behavior and initial state of objects of +the class. The extends clause ~\lstinline@extends $sc$ with $mt_1$ with $\ldots$ with $mt_m$@~ +can be omitted, in which case +~\lstinline@extends scala.AnyRef@~ is assumed. The class body +~\lstinline@{$\stats\,$}@~ may also be omitted, in which case the empty body +\lstinline@{}@ is assumed. +\end{itemize} +This class definition defines a type \lstinline@$c$[$\tps\,$]@ and a constructor +which when applied to parameters conforming to types $\ps$ +initializes instances of type \lstinline@$c$[$\tps\,$]@ by evaluating the template +$t$. + +\example The following example illustrates \code{val} and \code{var} +parameters of a class \code{C}: +\begin{lstlisting} +class C(x: Int, val y: String, var z: List[String]) +val c = new C(1, "abc", List()) +c.z = c.y :: c.z +\end{lstlisting} + +\example\label{ex:private-constr} +The following class can be created only from its companion +module. +\begin{lstlisting} +object Sensitive { + def makeSensitive(credentials: Certificate): Sensitive = + if (credentials == Admin) new Sensitive() + else throw new SecurityViolationException +} +class Sensitive private () { + ... +} +\end{lstlisting} + +\comment{ +For any index $i$ let $\csig_i$ be a class signature consisting of a class +name and optional type parameter and value parameter sections. Let $ct$ +be a class template. +Then a class definition +~\lstinline@class $\csig_1 \commadots \csig_n$ $ct$@~ +is a shorthand for the sequence of class definitions +~\lstinline@class $\csig_1$ $ct$; ...; class $\csig_n$ $ct$@. +A class definition +~\lstinline@class $\csig_1 \commadots \csig_n: T$ $ct$@~ +is a shorthand for the sequence of class definitions +~\lstinline@class $\csig_1: T$ $ct$; ...; class $\csig_n: T$ $ct$@. +} + +\subsection{Constructor Definitions}\label{sec:constr-defs} + +\syntax\begin{lstlisting} + FunDef ::= `this' ParamClause ParamClauses + (`=' ConstrExpr | [nl] ConstrBlock) + ConstrExpr ::= SelfInvocation + | ConstrBlock + ConstrBlock ::= `{' SelfInvocation {semi BlockStat} `}' + SelfInvocation ::= `this' ArgumentExprs {ArgumentExprs} +\end{lstlisting} + +A class may have additional constructors besides the primary +constructor. These are defined by constructor definitions of the form +~\lstinline@def this($\ps_1$)$\ldots$($\ps_n$) = $e$@. Such a +definition introduces an additional constructor for the enclosing +class, with parameters as given in the formal parameter lists $\ps_1 +\commadots \ps_n$, and whose evaluation is defined by the constructor +expression $e$. The scope of each formal parameter is the subsequent +parameter sections and the constructor +expression $e$. A constructor expression is either a self constructor +invocation \lstinline@this($\args_1$)$\ldots$($\args_n$)@ or a block +which begins with a self constructor invocation. The self constructor +invocation must construct a generic instance of the class. I.e.\ if the +class in question has name $C$ and type parameters +\lstinline@[$\tps\,$]@, then a self constructor invocation must +generate an instance of \lstinline@$C$[$\tps\,$]@; it is not permitted +to instantiate formal type parameters. + +The signature and the self constructor invocation of a constructor +definition are type-checked and evaluated in the scope which is in +effect at the point of the enclosing class definition, augmented by +any type parameters of the enclosing class and by any early +definitions (\sref{sec:early-defs}) of the enclosing template. +The rest of the +constructor expression is type-checked and evaluated as a function +body in the current class. + +If there are auxiliary constructors of a class $C$, they form together +with $C$'s primary constructor (\sref{sec:class-defs}) +an overloaded constructor +definition. The usual rules for overloading resolution +(\sref{sec:overloading-resolution}) apply for constructor invocations of $C$, +including for the self constructor invocations in the constructor +expressions themselves. However, unlike other methods, constructors +are never inherited. To prevent infinite cycles of constructor +invocations, there is the restriction that every self constructor +invocation must refer to a constructor definition which precedes it +(i.e.\ it must refer to either a preceding auxiliary constructor or the +primary constructor of the class). + +\example Consider the class definition + +\begin{lstlisting} +class LinkedList[A]() { + var head = _ + var tail = null + def isEmpty = tail != null + def this(head: A) = { this(); this.head = head } + def this(head: A, tail: List[A]) = { this(head); this.tail = tail } +} +\end{lstlisting} +This defines a class \code{LinkedList} with three constructors. The +second constructor constructs an singleton list, while the +third one constructs a list with a given head and tail. + +Case Classes +------------ + +\label{sec:case-classes} + +\syntax\begin{lstlisting} + TmplDef ::= `case' `class' ClassDef +\end{lstlisting} + +If a class definition is prefixed with \code{case}, the class is said +to be a {\em case class}. + +The formal parameters in the first parameter section of a case class +are called {\em elements}; they are treated +specially. First, the value of such a parameter can be extracted as a +field of a constructor pattern. Second, a \code{val} prefix is +implicitly added to such a parameter, unless the parameter carries +already a \code{val} or \code{var} modifier. Hence, an accessor +definition for the parameter is generated (\sref{sec:class-defs}). + +A case class definition of ~\lstinline@$c$[$\tps\,$]($\ps_1\,$)$\ldots$($\ps_n$)@~ with type +parameters $\tps$ and value parameters $\ps$ implicitly +generates an extractor object (\sref{sec:extractor-patterns}) which is +defined as follows: +\begin{lstlisting} + object $c$ { + def apply[$\tps\,$]($\ps_1\,$)$\ldots$($\ps_n$): $c$[$\tps\,$] = new $c$[$\Ts\,$]($\xs_1\,$)$\ldots$($\xs_n$) + def unapply[$\tps\,$]($x$: $c$[$\tps\,$]) = + if (x eq null) scala.None + else scala.Some($x.\xs_{11}\commadots x.\xs_{1k}$) + } +\end{lstlisting} +Here, + $\Ts$ stands for the vector of types defined in the type +parameter section $\tps$, +each $\xs_i$ denotes the parameter names of the parameter +section $\ps_i$, and +$\xs_{11}\commadots \xs_{1k}$ denote the names of all parameters +in the first parameter section $\xs_1$. +If a type parameter section is missing in the +class, it is also missing in the \lstinline@apply@ and +\lstinline@unapply@ methods. +The definition of \lstinline@apply@ is omitted if class $c$ is +\lstinline@abstract@. + +If the case class definition contains an empty value parameter list, the +\lstinline@unapply@ method returns a \lstinline@Boolean@ instead of an \lstinline@Option@ type and +is defined as follows: +\begin{lstlisting} + def unapply[$\tps\,$]($x$: $c$[$\tps\,$]) = x ne null +\end{lstlisting} +The name of the \lstinline@unapply@ method is changed to \lstinline@unapplySeq@ if the first +parameter section $\ps_1$ of $c$ ends in a repeated parameter of (\sref{sec:repeated-params}). +If a companion object $c$ exists already, no new object is created, +but the \lstinline@apply@ and \lstinline@unapply@ methods are added to the existing +object instead. + +A method named \code{copy} is implicitly added to every case class unless the +class already has a member (directly defined or inherited) with that name. The +method is defined as follows: +\begin{lstlisting} + def copy[$\tps\,$]($\ps'_1\,$)$\ldots$($\ps'_n$): $c$[$\tps\,$] = new $c$[$\Ts\,$]($\xs_1\,$)$\ldots$($\xs_n$) +\end{lstlisting} +Again, $\Ts$ stands for the vector of types defined in the type parameter section $\tps$ +and each $\xs_i$ denotes the parameter names of the parameter section $\ps'_i$. Every value +parameter $\ps'_{i,j}$ of the \code{copy} method has the form \lstinline@$x_{i,j}$:$T_{i,j}$=this.$x_{i,j}$@, +where $x_{i,j}$ and $T_{i,j}$ refer to the name and type of the corresponding class parameter +$\ps_{i,j}$. + +Every case class implicitly overrides some method definitions of class +\lstinline@scala.AnyRef@ (\sref{sec:cls-object}) unless a definition of the same +method is already given in the case class itself or a concrete +definition of the same method is given in some base class of the case +class different from \code{AnyRef}. In particular: +\begin{itemize} +\item[] Method ~\lstinline@equals: (Any)Boolean@~ is structural equality, where two +instances are equal if they both belong to the case class in question and they +have equal (with respect to \code{equals}) constructor arguments. +\item[] +Method ~\lstinline@hashCode: Int@ computes a hash-code. If the hashCode methods +of the data structure members map equal (with respect to equals) +values to equal hash-codes, then the case class hashCode method does +too. +\item[] Method ~\lstinline@toString: String@~ returns a string representation which +contains the name of the class and its elements. +\end{itemize} + +\example Here is the definition of abstract syntax for lambda +calculus: + +\begin{lstlisting} +class Expr +case class Var (x: String) extends Expr +case class Apply (f: Expr, e: Expr) extends Expr +case class Lambda(x: String, e: Expr) extends Expr +\end{lstlisting} +This defines a class \code{Expr} with case classes +\code{Var}, \code{Apply} and \code{Lambda}. A call-by-value evaluator for lambda +expressions could then be written as follows. + +\begin{lstlisting} +type Env = String => Value +case class Value(e: Expr, env: Env) + +def eval(e: Expr, env: Env): Value = e match { + case Var (x) => + env(x) + case Apply(f, g) => + val Value(Lambda (x, e1), env1) = eval(f, env) + val v = eval(g, env) + eval (e1, (y => if (y == x) v else env1(y))) + case Lambda(_, _) => + Value(e, env) +} +\end{lstlisting} + +It is possible to define further case classes that extend type +\code{Expr} in other parts of the program, for instance +\begin{lstlisting} +case class Number(x: Int) extends Expr +\end{lstlisting} + +This form of extensibility can be excluded by declaring the base class +\code{Expr} \code{sealed}; in this case, all classes that +directly extend \code{Expr} must be in the same source file as +\code{Expr}. + +\subsection{Traits} +\label{sec:traits} + +\syntax\begin{lstlisting} + TmplDef ::= `trait' TraitDef + TraitDef ::= id [TypeParamClause] TraitTemplateOpt + TraitTemplateOpt ::= `extends' TraitTemplate | [[`extends'] TemplateBody] +\end{lstlisting} + +A trait is a class that is meant to be added to some other class +as a mixin. Unlike normal classes, traits cannot have +constructor parameters. Furthermore, no constructor arguments are +passed to the superclass of the trait. This is not necessary as traits are +initialized after the superclass is initialized. + +Assume a trait $D$ defines some aspect of an instance $x$ of +type $C$ (i.e.\ $D$ is a base class of $C$). Then the {\em actual +supertype} of $D$ in $x$ is the compound type consisting of all the +base classes in $\lin C$ that succeed $D$. The actual supertype gives +the context for resolving a \code{super} reference in a trait +(\sref{sec:this-super}). Note that the actual supertype depends +on the type to which the trait is added in a mixin composition; it is not +statically known at the time the trait is defined. + +If $D$ is not a trait, then its actual supertype is simply its +least proper supertype (which is statically known). + +\example\label{ex:comparable} The following trait defines the property +of being comparable to objects of some type. It contains an abstract +method \lstinline@<@ and default implementations of the other +comparison operators \lstinline@<=@, \lstinline@>@, and +\lstinline@>=@. + +\begin{lstlisting} +trait Comparable[T <: Comparable[T]] { self: T => + def < (that: T): Boolean + def <=(that: T): Boolean = this < that || this == that + def > (that: T): Boolean = that < this + def >=(that: T): Boolean = that <= this +} +\end{lstlisting} + +\example Consider an abstract class \code{Table} that implements maps +from a type of keys \code{A} to a type of values \code{B}. The class +has a method \code{set} to enter a new key / value pair into the table, +and a method \code{get} that returns an optional value matching a +given key. Finally, there is a method \code{apply} which is like +\code{get}, except that it returns a given default value if the table +is undefined for the given key. This class is implemented as follows. +\begin{lstlisting} +abstract class Table[A, B](defaultValue: B) { + def get(key: A): Option[B] + def set(key: A, value: B) + def apply(key: A) = get(key) match { + case Some(value) => value + case None => defaultValue + } +} +\end{lstlisting} +Here is a concrete implementation of the \code{Table} class. +\begin{lstlisting} +class ListTable[A, B](defaultValue: B) extends Table[A, B](defaultValue) { + private var elems: List[(A, B)] + def get(key: A) = elems.find(._1.==(key)).map(._2) + def set(key: A, value: B) = { elems = (key, value) :: elems } +} +\end{lstlisting} +Here is a trait that prevents concurrent access to the +\code{get} and \code{set} operations of its parent class: +\begin{lstlisting} +trait SynchronizedTable[A, B] extends Table[A, B] { + abstract override def get(key: A): B = + synchronized { super.get(key) } + abstract override def set((key: A, value: B) = + synchronized { super.set(key, value) } +} + +\end{lstlisting} +Note that \code{SynchronizedTable} does not pass an argument to +its superclass, \code{Table}, even though \code{Table} is defined with a +formal parameter. Note also that the \code{super} calls +in \code{SynchronizedTable}'s \code{get} and \code{set} methods +statically refer to abstract methods in class \code{Table}. This is +legal, as long as the calling method is labeled +\code{abstract override} (\sref{sec:modifiers}). + +Finally, the following mixin composition creates a synchronized list table +with strings as keys and integers as values and with a default value \code{0}: +\begin{lstlisting} +object MyTable extends ListTable[String, Int](0) with SynchronizedTable +\end{lstlisting} +The object \code{MyTable} inherits its \code{get} and \code{set} +method from \code{SynchronizedTable}. The \code{super} calls in these +methods are re-bound to refer to the corresponding implementations in +\code{ListTable}, which is the actual supertype of \code{SynchronizedTable} +in \code{MyTable}. + +\section{Object Definitions} +\label{sec:object-defs} +\label{def:companion} + +\syntax\begin{lstlisting} + ObjectDef ::= id ClassTemplate +\end{lstlisting} + +An object definition defines a single object of a new class. Its +most general form is +~\lstinline@object $m$ extends $t$@. Here, +$m$ is the name of the object to be defined, and +$t$ is a template (\sref{sec:templates}) of the form +\begin{lstlisting} +$sc$ with $mt_1$ with $\ldots$ with $mt_n$ { $\stats$ } +\end{lstlisting} +which defines the base classes, behavior and initial state of $m$. +The extends clause ~\lstinline@extends $sc$ with $mt_1$ with $\ldots$ with $mt_n$@~ +can be omitted, in which case +~\lstinline@extends scala.AnyRef@~ is assumed. The class body +~\lstinline@{$\stats\,$}@~ may also be omitted, in which case the empty body +\lstinline@{}@ is assumed. + +The object definition defines a single object (or: {\em module}) +conforming to the template $t$. It is roughly equivalent to the +following definition of a lazy value: +\begin{lstlisting} +lazy val $m$ = new $sc$ with $mt_1$ with $\ldots$ with $mt_n$ { this: $m.type$ => $\stats$ } +\end{lstlisting} +Note that the value defined by an object definition is instantiated +lazily. The ~\lstinline@new $m\Dollar$cls@~ constructor is evaluated +not at the point of the object definition, but is instead evaluated +the first time $m$ is dereferenced during execution of the program +(which might be never at all). An attempt to dereference $m$ again in +the course of evaluation of the constructor leads to a infinite loop +or run-time error. +Other threads trying to dereference $m$ while the +constructor is being evaluated block until evaluation is complete. + +The expansion given above is not accurate for top-level objects. It +cannot be because variable and method definition cannot appear on the +top-level outside of a package object (\sref{sec:pkg-obj}). Instead, +top-level objects are translated to static fields. + +\example +Classes in Scala do not have static members; however, an equivalent +effect can be achieved by an accompanying object definition +E.g. +\begin{lstlisting} +abstract class Point { + val x: Double + val y: Double + def isOrigin = (x == 0.0 && y == 0.0) +} +object Point { + val origin = new Point() { val x = 0.0; val y = 0.0 } +} +\end{lstlisting} +This defines a class \code{Point} and an object \code{Point} which +contains \code{origin} as a member. Note that the double use of the +name \code{Point} is legal, since the class definition defines the +name \code{Point} in the type name space, whereas the object +definition defines a name in the term namespace. + +This technique is applied by the Scala compiler when interpreting a +Java class with static members. Such a class $C$ is conceptually seen +as a pair of a Scala class that contains all instance members of $C$ +and a Scala object that contains all static members of $C$. + +Generally, a {\em companion module} of a class is an object which has +the same name as the class and is defined in the same scope and +compilation unit. Conversely, the class is called the {\em companion class} +of the module. + + +\comment{ +Let $ct$ be a class template. +Then an object definition +~\lstinline@object $x_1 \commadots x_n$ $ct$@~ +is a shorthand for the sequence of object definitions +~\lstinline@object $x_1$ $ct$; ...; object $x_n$ $ct$@. +An object definition +~\lstinline@object $x_1 \commadots x_n: T$ $ct$@~ +is a shorthand for the sequence of object definitions +~\lstinline@object $x_1: T$ $ct$; ...; object $x_n: T$ $ct$@. +} + +\comment{ +\example Here's an outline of a module definition for a file system. + +\begin{lstlisting} +object FileSystem { + private type FileDirectory + private val dir: FileDirectory + + trait File { + def read(xs: Array[Byte]) + def close: Unit + } + + private class FileHandle extends File { $\ldots$ } + + def open(name: String): File = $\ldots$ +} +\end{lstlisting} +} + diff --git a/08-expressions.md b/08-expressions.md new file mode 100644 index 000000000000..928b56868b15 --- /dev/null +++ b/08-expressions.md @@ -0,0 +1,1876 @@ +Expressions +=========== + +\syntax\begin{lstlisting} + Expr ::= (Bindings | id | `_') `=>' Expr + | Expr1 + Expr1 ::= `if' `(' Expr `)' {nl} Expr [[semi] else Expr] + | `while' `(' Expr `)' {nl} Expr + | `try' `{' Block `}' [`catch' `{' CaseClauses `}'] + [`finally' Expr] + | `do' Expr [semi] `while' `(' Expr ')' + | `for' (`(' Enumerators `)' | `{' Enumerators `}') + {nl} [`yield'] Expr + | `throw' Expr + | `return' [Expr] + | [SimpleExpr `.'] id `=' Expr + | SimpleExpr1 ArgumentExprs `=' Expr + | PostfixExpr + | PostfixExpr Ascription + | PostfixExpr `match' `{' CaseClauses `}' + PostfixExpr ::= InfixExpr [id [nl]] + InfixExpr ::= PrefixExpr + | InfixExpr id [nl] InfixExpr + PrefixExpr ::= [`-' | `+' | `~' | `!'] SimpleExpr + SimpleExpr ::= `new' (ClassTemplate | TemplateBody) + | BlockExpr + | SimpleExpr1 [`_'] + SimpleExpr1 ::= Literal + | Path + | `_' + | `(' [Exprs] `)' + | SimpleExpr `.' id s + | SimpleExpr TypeArgs + | SimpleExpr1 ArgumentExprs + | XmlExpr + Exprs ::= Expr {`,' Expr} + BlockExpr ::= `{' CaseClauses `}' + | `{' Block `}' + Block ::= {BlockStat semi} [ResultExpr] + ResultExpr ::= Expr1 + | (Bindings | ([`implicit'] id | `_') `:' CompoundType) `=>' Block + Ascription ::= `:' InfixType + | `:' Annotation {Annotation} + | `:' `_' `*' +\end{lstlisting} + +Expressions are composed of operators and operands. Expression forms are +discussed subsequently in decreasing order of precedence. + +Expression Typing +----------------- + +\label{sec:expr-typing} + +The typing of expressions is often relative to some {\em expected +type} (which might be undefined). +When we write ``expression $e$ is expected to conform to +type $T$'', we mean: (1) the expected type of $e$ is +$T$, and (2) the type of expression $e$ must conform to +$T$. + +The following skolemization rule is applied universally for every +expression: If the type of an expression would be an existential type +$T$, then the type of the expression is assumed instead to be a +skolemization (\sref{sec:existential-types}) of $T$. + +Skolemization is reversed by type packing. Assume an expression $e$ of +type $T$ and let $t_1[\tps_1] >: L_1 <: U_1 \commadots t_n[\tps_n] >: L_n <: U_n$ be +all the type variables created by skolemization of some part of $e$ which are free in $T$. +Then the {\em packed type} of $e$ is +\begin{lstlisting} +$T$ forSome { type $t_1[\tps_1] >: L_1 <: U_1$; $\ldots$; type $t_n[\tps_n] >: L_n <: U_n$ }. +\end{lstlisting} + +\section{Literals}\label{sec:literal-exprs} + +\syntax\begin{lstlisting} + SimpleExpr ::= Literal +\end{lstlisting} + +Typing of literals is as described in (\sref{sec:literals}); their +evaluation is immediate. + + +\section{The {\em Null} Value} + +The \code{null} value is of type \lstinline@scala.Null@, and is thus +compatible with every reference type. It denotes a reference value +which refers to a special ``\lstinline@null@'' object. This object +implements methods in class \lstinline@scala.AnyRef@ as follows: +\begin{itemize} +\item +\lstinline@eq($x\,$)@ and \lstinline@==($x\,$)@ return \code{true} iff the +argument $x$ is also the ``null'' object. +\item +\lstinline@ne($x\,$)@ and \lstinline@!=($x\,$)@ return true iff the +argument x is not also the ``null'' object. +\item +\lstinline@isInstanceOf[$T\,$]@ always returns \code{false}. +\item +\lstinline@asInstanceOf[$T\,$]@ returns the ``null'' object itself if +$T$ conforms to \lstinline@scala.AnyRef@, and throws a +\lstinline@NullPointerException@ otherwise. +\end{itemize} +A reference to any other member of the ``null'' object causes a +\code{NullPointerException} to be thrown. + +\section{Designators} +\label{sec:designators} + +\syntax\begin{lstlisting} + SimpleExpr ::= Path + | SimpleExpr `.' id +\end{lstlisting} + +A designator refers to a named term. It can be a {\em simple name} or +a {\em selection}. + +A simple name $x$ refers to a value as specified in \sref{sec:names}. +If $x$ is bound by a definition or declaration in an enclosing class +or object $C$, it is taken to be equivalent to the selection +\lstinline@$C$.this.$x$@ where $C$ is taken to refer to the class containing $x$ +even if the type name $C$ is shadowed (\sref{sec:names}) at the +occurrence of $x$. + +If $r$ is a stable identifier +(\sref{sec:stable-ids}) of type $T$, the selection $r.x$ refers +statically to a term member $m$ of $r$ that is identified in $T$ by +the name $x$. \comment{There might be several such members, in which +case overloading resolution (\sref{overloading-resolution}) is applied +to pick a unique one.} + +For other expressions $e$, $e.x$ is typed as +if it was ~\lstinline@{ val $y$ = $e$; $y$.$x$ }@, for some fresh name +$y$. + +The expected type of a designator's prefix is always undefined. The +type of a designator is the type $T$ of the entity it refers to, with +the following exception: The type of a path (\sref{sec:paths}) $p$ +which occurs in a context where a stable type +(\sref{sec:singleton-types}) is required is the singleton type +\lstinline@$p$.type@. + +The contexts where a stable type is required are those that satisfy +one of the following conditions: +\begin{enumerate} +\item +The path $p$ occurs as the prefix of a selection and it does not +designate a constant, or +\item +The expected type $\proto$ is a stable type, or +\item +The expected type $\proto$ is an abstract type with a stable type as lower +bound, and the type $T$ of the entity referred to by $p$ does not +conform to $\proto$, or +\item +The path $p$ designates a module. +\end{enumerate} + +The selection $e.x$ is evaluated by first evaluating the qualifier +expression $e$, which yields an object $r$, say. The selection's +result is then the member of $r$ that is either defined by $m$ or defined +by a definition overriding $m$. +If that member has a type which +conforms to \lstinline@scala.NotNull@, the member's value must be initialized +to a value different from \lstinline@null@, otherwise a \lstinline@scala.UnitializedError@ +is thrown. + + +\section{This and Super} +\label{sec:this-super} + +\syntax\begin{lstlisting} + SimpleExpr ::= [id `.'] `this' + | [id '.'] `super' [ClassQualifier] `.' id +\end{lstlisting} + +The expression \code{this} can appear in the statement part of a +template or compound type. It stands for the object being defined by +the innermost template or compound type enclosing the reference. If +this is a compound type, the type of \code{this} is that compound type. +If it is a template of a +class or object definition with simple name $C$, the type of this +is the same as the type of \lstinline@$C$.this@. + +The expression \lstinline@$C$.this@ is legal in the statement part of an +enclosing class or object definition with simple name $C$. It +stands for the object being defined by the innermost such definition. +If the expression's expected type is a stable type, or +\lstinline@$C$.this@ occurs as the prefix of a selection, its type is +\lstinline@$C$.this.type@, otherwise it is the self type of class $C$. + +A reference ~\lstinline@super.$m$@~ refers statically to a method or type $m$ +in the least proper supertype of the innermost template containing the +reference. It evaluates to the member $m'$ in the actual supertype of +that template which is equal to $m$ or which overrides $m$. The +statically referenced member $m$ must be a type or a +method. +%explanation: so that we need not create several fields for overriding vals +If it is +a method, it must be concrete, or the template +containing the reference must have a member $m'$ which overrides $m$ +and which is labeled \code{abstract override}. + +A reference ~\lstinline@$C$.super.$m$@~ refers statically to a method +or type $m$ in the least proper supertype of the innermost enclosing class or +object definition named $C$ which encloses the reference. It evaluates +to the member $m'$ in the actual supertype of that class or object +which is equal to $m$ or which overrides $m$. The +statically referenced member $m$ must be a type or a +method. If the statically +referenced member $m$ is a method, it must be concrete, or the innermost enclosing +class or object definition named $C$ must have a member $m'$ which +overrides $m$ and which is labeled \code{abstract override}. + +The \code{super} prefix may be followed by a trait qualifier +\lstinline@[$T\,$]@, as in \lstinline@$C$.super[$T\,$].$x$@. This is +called a {\em static super reference}. In this case, the reference is +to the type or method of $x$ in the parent trait of $C$ whose simple +name is $T$. That member must be uniquely defined. If it is a method, +it must be concrete. + +\example\label{ex:super} +Consider the following class definitions + +\begin{lstlisting} +class Root { def x = "Root" } +class A extends Root { override def x = "A" ; def superA = super.x } +trait B extends Root { override def x = "B" ; def superB = super.x } +class C extends Root with B { + override def x = "C" ; def superC = super.x +} +class D extends A with B { + override def x = "D" ; def superD = super.x +} +\end{lstlisting} +The linearization of class \code{C} is ~\lstinline@{C, B, Root}@~ and +the linearization of class \code{D} is ~\lstinline@{D, B, A, Root}@. +Then we have: +\begin{lstlisting} +(new A).superA == "Root", + (new C).superB = "Root", (new C).superC = "B", +(new D).superA == "Root", (new D).superB = "A", (new D).superD = "B", +\end{lstlisting} +Note that the \code{superB} function returns different results +depending on whether \code{B} is mixed in with class \code{Root} or \code{A}. + +\comment{ +\example Consider the following class definitions: +\begin{lstlisting} +class Shape { + override def equals(other: Any) = $\ldots$ + $\ldots$ +} +trait Bordered extends Shape { + val thickness: Int + override def equals(other: Any) = other match { + case that: Bordered => + super equals other && this.thickness == that.thickness + case _ => false + } + $\ldots$ +} +trait Colored extends Shape { + val color: Color + override def equals(other: Any) = other match { + case that: Colored => + super equals other && this.color == that.color + case _ => false + } + $\ldots$ +} +\end{lstlisting} + +Both definitions of \code{equals} are combined in the class +below. +\begin{lstlisting} +trait BorderedColoredShape extends Shape with Bordered with Colored { + override def equals(other: Any) = + super[Bordered].equals(that) && super[Colored].equals(that) +} +\end{lstlisting} +} + +\section{Function Applications} +\label{sec:apply} + +\syntax\begin{lstlisting} + SimpleExpr ::= SimpleExpr1 ArgumentExprs + ArgumentExprs ::= `(' [Exprs] `)' + | `(' [Exprs `,'] PostfixExpr `:' `_' `*' ')' + | [nl] BlockExpr + Exprs ::= Expr {`,' Expr} +\end{lstlisting} + +An application \lstinline@$f$($e_1 \commadots e_m$)@ applies the +function $f$ to the argument expressions $e_1 \commadots e_m$. If $f$ +has a method type \lstinline@($p_1$:$T_1 \commadots p_n$:$T_n$)$U$@, the type of +each argument expression $e_i$ is typed with the +corresponding parameter type $T_i$ as expected type. Let $S_i$ be type +type of argument $e_i$ $(i = 1 \commadots m)$. If $f$ is a polymorphic method, +local type inference (\sref{sec:local-type-inf}) is used to determine +type arguments for $f$. If $f$ has some value type, the application is taken to +be equivalent to \lstinline@$f$.apply($e_1 \commadots e_m$)@, +i.e.\ the application of an \code{apply} method defined by $f$. + +The function $f$ must be {\em applicable} to its arguments $e_1 +\commadots e_n$ of types $S_1 \commadots S_n$. + +If $f$ has a method type $(p_1:T_1 \commadots p_n:T_n)U$ +we say that an argument expression $e_i$ is a {\em named} argument if +it has the form $x_i=e'_i$ and $x_i$ is one of the parameter names +$p_1 \commadots p_n$. The function $f$ is applicable if all of the follwing conditions +hold: + +\begin{itemize} +\item For every named argument $x_i=e'_i$ the type $S_i$ + is compatible with the parameter type $T_j$ whose name $p_j$ matches $x_i$. +\item For every positional argument $e_i$ the type $S_i$ +is compatible with $T_i$. +%\item Every parameter $p_j:T_j$ which is not specified by either a positional +% or a named argument has a default argument. +%\item The named arguments form a suffix of the argument list $e_1 \commadots e_m$, +% i.e.\ no positional argument follows a named one. +%\item The names $x_i$ of all named arguments are pairwise distinct and no named +% argument defines a parameter which is already specified by a +% positional argument. +%\item Every formal parameter $p_j:T_j$ which is not specified by either a positional +% or a named argument has a default argument. +\item If the expected type is defined, the result type $U$ is +compatible to it. +\end{itemize} + +If $f$ is a polymorphic method it is applicable if local type +inference (\sref{sec:local-type-inf}) can +determine type arguments so that the instantiated method is applicable. If +$f$ has some value type it is applicable if it has a method member named +\code{apply} which is applicable. + + +%Class constructor functions +%(\sref{sec:class-defs}) can only be applied in constructor invocations +%(\sref{sec:constr-invoke}), never in expressions. + +Evaluation of \lstinline@$f$($e_1 \commadots e_n$)@ usually entails evaluation of +$f$ and $e_1 \commadots e_n$ in that order. Each argument expression +is converted to the type of its corresponding formal parameter. After +that, the application is rewritten to the function's right hand side, +with actual arguments substituted for formal parameters. The result +of evaluating the rewritten right-hand side is finally converted to +the function's declared result type, if one is given. + +The case of a formal parameter with a parameterless +method type ~\lstinline@=>$T$@~ is treated specially. In this case, the +corresponding actual argument expression $e$ is not evaluated before the +application. Instead, every use of the formal parameter on the +right-hand side of the rewrite rule entails a re-evaluation of $e$. +In other words, the evaluation order for +\code{=>}-parameters is {\em call-by-name} whereas the evaluation +order for normal parameters is {\em call-by-value}. +Furthermore, it is required that $e$'s packed type (\sref{sec:expr-typing}) +conforms to the parameter type $T$. +The behavior of by-name parameters is preserved if the application is +transformed into a block due to named or default arguments. In this case, +the local value for that parameter has the form \lstinline@val $y_i$ = () => $e$@ +and the argument passed to the function is \lstinline@$y_i$()@. + +The last argument in an application may be marked as a sequence +argument, e.g.\ \lstinline@$e$: _*@. Such an argument must correspond +to a repeated parameter (\sref{sec:repeated-params}) of type +\lstinline@$S$*@ and it must be the only argument matching this +parameter (i.e.\ the number of formal parameters and actual arguments +must be the same). Furthermore, the type of $e$ must conform to +~\lstinline@scala.Seq[$T$]@, for some type $T$ which conforms to +$S$. In this case, the argument list is transformed by replacing the +sequence $e$ with its elements. When the application uses named +arguments, the vararg parameter has to be specified exactly once. + +A function application usually allocates a new frame on the program's +run-time stack. However, if a local function or a final method calls +itself as its last action, the call is executed using the stack-frame +of the caller. + +\example Assume the following function which computes the sum of a +variable number of arguments: +\begin{lstlisting} +def sum(xs: Int*) = (0 /: xs) ((x, y) => x + y) +\end{lstlisting} +Then +\begin{lstlisting} +sum(1, 2, 3, 4) +sum(List(1, 2, 3, 4): _*) +\end{lstlisting} +both yield \code{10} as result. On the other hand, +\begin{lstlisting} +sum(List(1, 2, 3, 4)) +\end{lstlisting} +would not typecheck. + +\subsection{Named and Default Arguments} +\label{sec:named-default} + +If an application might uses named arguments $p = e$ or default +arguments, the following conditions must hold. +\begin{itemize} +\item The named arguments form a suffix of the argument list $e_1 \commadots e_m$, + i.e.\ no positional argument follows a named one. +\item The names $x_i$ of all named arguments are pairwise distinct and no named + argument defines a parameter which is already specified by a + positional argument. +\item Every formal parameter $p_j:T_j$ which is not specified by either a positional + or a named argument has a default argument. +\end{itemize} + +If the application uses named or default +arguments the following transformation is applied to convert it into +an application without named or default arguments. + +If the function $f$ +has the form \lstinline@$p.m$[$\targs$]@ it is transformed into the +block +\begin{lstlisting} +{ val q = $p$ + q.$m$[$\targs$] +} +\end{lstlisting} +If the function $f$ is itself an application expression the transformation +is applied recursively on $f$. The result of transforming $f$ is a block of +the form +\begin{lstlisting} +{ val q = $p$ + val $x_1$ = expr$_1$ + $\ldots$ + val $x_k$ = expr$_k$ + q.$m$[$\targs$]($\args_1$)$\commadots$($\args_l$) +} +\end{lstlisting} +where every argument in $(\args_1) \commadots (\args_l)$ is a reference to +one of the values $x_1 \commadots x_k$. To integrate the current application +into the block, first a value definition using a fresh name $y_i$ is created +for every argument in $e_1 \commadots e_m$, which is initialised to $e_i$ for +positional arguments and to $e'_i$ for named arguments of the form +\lstinline@$x_i=e'_i$@. Then, for every parameter which is not specified +by the argument list, a value definition using a fresh name $z_i$ is created, +which is initialized using the method computing the default argument of +this parameter (\sref{sec:funsigs}). + +Let $\args$ be a permutation of the generated names $y_i$ and $z_i$ such such +that the position of each name matches the position of its corresponding +parameter in the method type \lstinline@($p_1:T_1 \commadots p_n:T_n$)$U$@. +The final result of the transformation is a block of the form +\begin{lstlisting} +{ val q = $p$ + val $x_1$ = expr$_1$ + $\ldots$ + val $x_l$ = expr$_k$ + val $y_1$ = $e_1$ + $\ldots$ + val $y_m$ = $e_m$ + val $z_1$ = q.$m\Dollar$default$\Dollar$i[$\targs$]($\args_1$)$\commadots$($\args_l$) + $\ldots$ + val $z_d$ = q.$m\Dollar$default$\Dollar$j[$\targs$]($\args_1$)$\commadots$($\args_l$) + q.$m$[$\targs$]($\args_1$)$\commadots$($\args_l$)($\args$) +} +\end{lstlisting} + + +\section{Method Values}\label{sec:meth-vals} + +\syntax\begin{lstlisting} + SimpleExpr ::= SimpleExpr1 `_' +\end{lstlisting} + +The expression ~~\lstinline@$e$ _@~~ is well-formed if $e$ is of method +type or if $e$ is a call-by-name parameter. If $e$ is a method with +parameters, \lstinline@$e$ _@~~ represents $e$ converted to a function +type by eta expansion (\sref{sec:eta-expand}). If $e$ is a +parameterless method or call-by-name parameter of type +\lstinline@=>$T$@, ~\lstinline@$e$ _@~~ represents the function of type +\lstinline@() => $T$@, which evaluates $e$ when it is applied to the empty +parameterlist \lstinline@()@. + +\example The method values in the left column are each equivalent to the +anonymous functions (\sref{sec:closures}) on their right. + +\begin{lstlisting} +Math.sin _ x => Math.sin(x) +Array.range _ (x1, x2) => Array.range(x1, x2) +List.map2 _ (x1, x2) => (x3) => List.map2(x1, x2)(x3) +List.map2(xs, ys)_ x => List.map2(xs, ys)(x) +\end{lstlisting} + +Note that a space is necessary between a method name and the trailing underscore +because otherwise the underscore would be considered part of the name. + +\section{Type Applications} +\label{sec:type-app} +\syntax\begin{lstlisting} + SimpleExpr ::= SimpleExpr TypeArgs +\end{lstlisting} + +A type application \lstinline@$e$[$T_1 \commadots T_n$]@ instantiates +a polymorphic value $e$ of type ~\lstinline@[$a_1$ >: $L_1$ <: $U_1 +\commadots a_n$ >: $L_n$ <: $U_n$]$S$@~ with argument types +\lstinline@$T_1 \commadots T_n$@. Every argument type $T_i$ must obey +the corresponding bounds $L_i$ and $U_i$. That is, for each $i = 1 +\commadots n$, we must have $\sigma L_i \conforms T_i \conforms \sigma +U_i$, where $\sigma$ is the substitution $[a_1 := T_1 \commadots a_n +:= T_n]$. The type of the application is $\sigma S$. + +If the function part $e$ is of some value type, the type application +is taken to be equivalent to +~\lstinline@$e$.apply[$T_1 \commadots$ T$_n$]@, i.e.\ the application of an \code{apply} method defined by +$e$. + +Type applications can be omitted if local type inference +(\sref{sec:local-type-inf}) can infer best type parameters for a +polymorphic functions from the types of the actual function arguments +and the expected result type. + +\section{Tuples} +\label{sec:tuples} + +\syntax\begin{lstlisting} + SimpleExpr ::= `(' [Exprs] `)' +\end{lstlisting} + +A tuple expression \lstinline@($e_1 \commadots e_n$)@ is an alias +for the class instance creation +~\lstinline@scala.Tuple$n$($e_1 \commadots e_n$)@, where $n \geq 2$. +The empty tuple +\lstinline@()@ is the unique value of type \lstinline@scala.Unit@. + +\section{Instance Creation Expressions} +\label{sec:inst-creation} + +\syntax\begin{lstlisting} + SimpleExpr ::= `new' (ClassTemplate | TemplateBody) +\end{lstlisting} + +A simple instance creation expression is of the form +~\lstinline@new $c$@~ +where $c$ is a constructor invocation +(\sref{sec:constr-invoke}). Let $T$ be the type of $c$. Then $T$ must +denote a (a type instance of) a non-abstract subclass of +\lstinline@scala.AnyRef@. Furthermore, the {\em concrete self type} of the +expression must conform to the self type of the class denoted by $T$ +(\sref{sec:templates}). The concrete self type is normally +$T$, except if the expression ~\lstinline@new $c$@~ appears as the +right hand side of a value definition +\begin{lstlisting} +val $x$: $S$ = new $c$ +\end{lstlisting} +(where the type annotation ~\lstinline@: $S$@~ may be missing). +In the latter case, the concrete self type of the expression is the +compound type ~\lstinline@$T$ with $x$.type@. + +The expression is evaluated by creating a fresh +object of type $T$ which is is initialized by evaluating $c$. The +type of the expression is $T$. + +A general instance creation expression is of the form +~\lstinline@new $t$@~ for some class template $t$ (\sref{sec:templates}). +Such an expression is equivalent to the block +\begin{lstlisting} +{ class $a$ extends $t$; new $a$ } +\end{lstlisting} +where $a$ is a fresh name of an {\em anonymous class} which is +inaccessible to user programs. + +There is also a shorthand form for creating values of structural +types: If ~\lstinline@{$D$}@ is a class body, then +~\lstinline@new {$D$}@~ is equivalent to the general instance creation expression +~\lstinline@new AnyRef{$D$}@. + +\example Consider the following structural instance creation +expression: +\begin{lstlisting} +new { def getName() = "aaron" } +\end{lstlisting} +This is a shorthand for the general instance creation expression +\begin{lstlisting} +new AnyRef{ def getName() = "aaron" } +\end{lstlisting} +The latter is in turn a shorthand for the block +\begin{lstlisting} +{ class anon$\Dollar$X extends AnyRef{ def getName() = "aaron" }; new anon$\Dollar$X } +\end{lstlisting} +where \lstinline@anon$\Dollar$X@ is some freshly created name. + +\section{Blocks} +\label{sec:blocks} + +\syntax\begin{lstlisting} + BlockExpr ::= `{' Block `}' + Block ::= {BlockStat semi} [ResultExpr] +\end{lstlisting} + +A block expression ~\lstinline@{$s_1$; $\ldots$; $s_n$; $e\,$}@~ is +constructed from a sequence of block statements $s_1 \commadots s_n$ +and a final expression $e$. The statement sequence may not contain +two definitions or declarations that bind the same name in the same +namespace. The final expression can be omitted, in which +case the unit value \lstinline@()@ is assumed. + +%Whether or not the scope includes the statement itself +%depends on the kind of definition. + +The expected type of the final expression $e$ is the expected +type of the block. The expected type of all preceding statements is +undefined. + +The type of a block ~\lstinline@$s_1$; $\ldots$; $s_n$; $e$@~ is +\lstinline@$T$ forSome {$\,Q\,$}@, where $T$ is the type of $e$ and $Q$ +contains existential clauses (\sref{sec:existential-types}) +for every value or type name which is free in $T$ +and which is defined locally in one of the statements $s_1 \commadots s_n$. +We say the existential clause {\em binds} the occurrence of the value or type name. +Specifically, +\begin{itemize} +\item +A locally defined type definition ~\lstinline@type$\;t = T$@~ +is bound by the existential clause ~\lstinline@type$\;t >: T <: T$@. +It is an error if $t$ carries type parameters. +\item +A locally defined value definition~ \lstinline@val$\;x: T = e$@~ is +bound by the existential clause ~\lstinline@val$\;x: T$@. +\item +A locally defined class definition ~\lstinline@class$\;c$ extends$\;t$@~ +is bound by the existential clause ~\lstinline@type$\;c <: T$@~ where +$T$ is the least class type or refinement type which is a proper +supertype of the type $c$. It is an error if $c$ carries type parameters. +\item +A locally defined object definition ~\lstinline@object$\;x\;$extends$\;t$@~ +is bound by the existential clause \lstinline@val$\;x: T$@ where +$T$ is the least class type or refinement type which is a proper supertype of the type +\lstinline@$x$.type@. +\end{itemize} +Evaluation of the block entails evaluation of its +statement sequence, followed by an evaluation of the final expression +$e$, which defines the result of the block. + +\example +Assuming a class \lstinline@Ref[T](x: T)@, the block +\begin{lstlisting} +{ class C extends B {$\ldots$} ; new Ref(new C) } +\end{lstlisting} +has the type ~\lstinline@Ref[_1] forSome { type _1 <: B }@. +The block +\begin{lstlisting} +{ class C extends B {$\ldots$} ; new C } +\end{lstlisting} +simply has type \code{B}, because with the rules in +(\sref{sec:ex-simpl} the existentially quantified type +~\lstinline@_1 forSome { type _1 <: B }@~ can be simplified to \code{B}. + + +Prefix, Infix, and Postfix Operations +------------------------------------- + +\label{sec:infix-operations} + +\syntax\begin{lstlisting} + PostfixExpr ::= InfixExpr [id [nl]] + InfixExpr ::= PrefixExpr + | InfixExpr id [nl] InfixExpr + PrefixExpr ::= [`-' | `+' | `!' | `~'] SimpleExpr +\end{lstlisting} + +Expressions can be constructed from operands and operators. + +\subsection{Prefix Operations} + +A prefix operation $\op;e$ consists of a prefix operator $\op$, which +must be one of the identifiers `\lstinline@+@', `\lstinline@-@', +`\lstinline@!@' or `\lstinline@~@'. The expression $\op;e$ is +equivalent to the postfix method application +\lstinline@e.unary_$\op$@. + +\todo{Generalize to arbitrary operators} + +Prefix operators are different from normal function applications in +that their operand expression need not be atomic. For instance, the +input sequence \lstinline@-sin(x)@ is read as \lstinline@-(sin(x))@, whereas the +function application \lstinline@negate sin(x)@ would be parsed as the +application of the infix operator \code{sin} to the operands +\code{negate} and \lstinline@(x)@. + +\subsection{Postfix Operations} + +A postfix operator can be an arbitrary identifier. The postfix +operation $e;\op$ is interpreted as $e.\op$. + +\subsection{Infix Operations} + +An infix operator can be an arbitrary identifier. Infix operators have +precedence and associativity defined as follows: + +The {\em precedence} of an infix operator is determined by the operator's first +character. Characters are listed below in increasing order of +precedence, with characters on the same line having the same precedence. +\begin{lstlisting} + $\mbox{\rm\sl(all letters)}$ + | + ^ + & + < > + = ! + : + + - + * / % + $\mbox{\rm\sl(all other special characters)}$ +\end{lstlisting} +That is, operators starting with a letter have lowest precedence, +followed by operators starting with `\lstinline@|@', etc. + +There's one exception to this rule, which concerns +{\em assignment operators}(\sref{sec:assops}). +The precedence of an assigment operator is the same as the one +of simple assignment \code{(=)}. That is, it is lower than the +precedence of any other operator. + +The {\em associativity} of an operator is determined by the operator's +last character. Operators ending in a colon `\lstinline@:@' are +right-associative. All other operators are left-associative. + +Precedence and associativity of operators determine the grouping of +parts of an expression as follows. +\begin{itemize} +\item If there are several infix operations in an +expression, then operators with higher precedence bind more closely +than operators with lower precedence. +\item If there are consecutive infix +operations $e_0; \op_1; e_1; \op_2 \ldots \op_n; e_n$ +with operators $\op_1 \commadots \op_n$ of the same precedence, +then all these operators must +have the same associativity. If all operators are left-associative, +the sequence is interpreted as +$(\ldots(e_0;\op_1;e_1);\op_2\ldots);\op_n;e_n$. +Otherwise, if all operators are right-associative, the +sequence is interpreted as +$e_0;\op_1;(e_1;\op_2;(\ldots \op_n;e_n)\ldots)$. +\item +Postfix operators always have lower precedence than infix +operators. E.g.\ $e_1;\op_1;e_2;\op_2$ is always equivalent to +$(e_1;\op_1;e_2);\op_2$. +\end{itemize} +The right-hand operand of a left-associative operator may consist of +several arguments enclosed in parentheses, e.g. $e;\op;(e_1,\ldots,e_n)$. +This expression is then interpreted as $e.\op(e_1,\ldots,e_n)$. + +A left-associative binary +operation $e_1;\op;e_2$ is interpreted as $e_1.\op(e_2)$. If $\op$ is +right-associative, the same operation is interpreted as +~\lstinline@{ val $x$=$e_1$; $e_2$.$\op$($x\,$) }@, where $x$ is a fresh +name. + +\subsection{Assignment Operators} \label{sec:assops} + +An assignment operator is an operator symbol (syntax category +\lstinline@op@ in [Identifiers](#identifiers)) that ends in an equals character +``\code{=}'', with the exception of operators for which one of +the following conditions holds: +\begin{itemize} +\item[(1)] the operator also starts with an equals character, or +\item[(2)] the operator is one of \code{(<=)}, \code{(>=)}, + \code{(!=)}. +\end{itemize} + +Assignment operators are treated specially in that they +can be expanded to assignments if no other interpretation is valid. + +Let's consider an assignment operator such as \code{+=} in an infix +operation ~\lstinline@$l$ += $r$@, where $l$, $r$ are expressions. +This operation can be re-interpreted as an operation which corresponds +to the assignment +\begin{lstlisting} +$l$ = $l$ + $r$ +\end{lstlisting} +except that the operation's left-hand-side $l$ is evaluated only once. + +The re-interpretation occurs if the following two conditions are fulfilled. +\begin{enumerate} +\item +The left-hand-side $l$ does not have a member named +\code{+=}, and also cannot be converted by an implicit conversion (\sref{sec:impl-conv}) +to a value with a member named \code{+=}. +\item +The assignment \lstinline@$l$ = $l$ + $r$@ is type-correct. +In particular this implies that $l$ refers to a variable or object +that can be assigned to, and that is convertible to a value with a member named \code{+}. +\end{enumerate} + +\section{Typed Expressions} + +\syntax\begin{lstlisting} + Expr1 ::= PostfixExpr `:' CompoundType +\end{lstlisting} + +The typed expression $e: T$ has type $T$. The type of +expression $e$ is expected to conform to $T$. The result of +the expression is the value of $e$ converted to type $T$. + +\example Here are examples of well-typed and illegally typed expressions. + +\begin{lstlisting} + 1: Int // legal, of type Int + 1: Long // legal, of type Long + // 1: string // ***** illegal +\end{lstlisting} + + + +\section{Annotated Expressions} + +\syntax\begin{lstlisting} + Expr1 ::= PostfixExpr `:' Annotation {Annotation} +\end{lstlisting} + +An annotated expression ~\lstinline^$e$: @$a_1$ $\ldots$ @$a_n$^ +attaches annotations $a_1 \commadots a_n$ to the expression $e$ +(\sref{sec:annotations}). + +\section{Assignments}\label{sec:assigments} + +\syntax\begin{lstlisting} + Expr1 ::= [SimpleExpr `.'] id `=' Expr + | SimpleExpr1 ArgumentExprs `=' Expr +\end{lstlisting} + +The interpretation of an assignment to a simple variable ~\lstinline@$x$ = $e$@~ +depends on the definition of $x$. If $x$ denotes a mutable +variable, then the assignment changes the current value of $x$ to be +the result of evaluating the expression $e$. The type of $e$ is +expected to conform to the type of $x$. If $x$ is a parameterless +function defined in some template, and the same template contains a +setter function \lstinline@$x$_=@ as member, then the assignment +~\lstinline@$x$ = $e$@~ is interpreted as the invocation +~\lstinline@$x$_=($e\,$)@~ of that setter function. Analogously, an +assignment ~\lstinline@$f.x$ = $e$@~ to a parameterless function $x$ +is interpreted as the invocation ~\lstinline@$f.x$_=($e\,$)@. + +An assignment ~\lstinline@$f$($\args\,$) = $e$@~ with a function application to the +left of the `\lstinline@=@' operator is interpreted as +~\lstinline@$f.$update($\args$, $e\,$)@, i.e.\ +the invocation of an \code{update} function defined by $f$. + +\example +Here are some assignment expressions and their equivalent expansions. +\begin{lstlisting} +x.f = e x.f_=(e) +x.f() = e x.f.update(e) +x.f(i) = e x.f.update(i, e) +x.f(i, j) = e x.f.update(i, j, e) +\end{lstlisting} + +\example \label{ex:imp-mat-mul} +Here is the usual imperative code for matrix multiplication. + +\begin{lstlisting} +def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = { + val zss: Array[Array[Double]] = new Array(xss.length, yss(0).length) + var i = 0 + while (i < xss.length) { + var j = 0 + while (j < yss(0).length) { + var acc = 0.0 + var k = 0 + while (k < yss.length) { + acc = acc + xss(i)(k) * yss(k)(j) + k += 1 + } + zss(i)(j) = acc + j += 1 + } + i += 1 + } + zss +} +\end{lstlisting} +Desugaring the array accesses and assignments yields the following +expanded version: +\begin{lstlisting} +def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = { + val zss: Array[Array[Double]] = new Array(xss.length, yss.apply(0).length) + var i = 0 + while (i < xss.length) { + var j = 0 + while (j < yss.apply(0).length) { + var acc = 0.0 + var k = 0 + while (k < yss.length) { + acc = acc + xss.apply(i).apply(k) * yss.apply(k).apply(j) + k += 1 + } + zss.apply(i).update(j, acc) + j += 1 + } + i += 1 + } + zss +} +\end{lstlisting} + +Conditional Expressions +----------------------- + +\label{sec:cond} + +\syntax\begin{lstlisting} + Expr1 ::= `if' `(' Expr `)' {nl} Expr [[semi] `else' Expr] +\end{lstlisting} + +The conditional expression ~\lstinline@if ($e_1$) $e_2$ else $e_3$@~ chooses +one of the values of $e_2$ and $e_3$, depending on the +value of $e_1$. The condition $e_1$ is expected to +conform to type \code{Boolean}. The then-part $e_2$ and the +else-part $e_3$ are both expected to conform to the expected +type of the conditional expression. The type of the conditional +expression is the weak least upper bound (\sref{sec:weakconformance}) +of the types of $e_2$ and +$e_3$. A semicolon preceding the \code{else} symbol of a +conditional expression is ignored. + +The conditional expression is evaluated by evaluating first +$e_1$. If this evaluates to \code{true}, the result of +evaluating $e_2$ is returned, otherwise the result of +evaluating $e_3$ is returned. + +A short form of the conditional expression eliminates the +else-part. The conditional expression ~\lstinline@if ($e_1$) $e_2$@~ is +evaluated as if it was ~\lstinline@if ($e_1$) $e_2$ else ()@. + +While Loop Expressions +---------------------- + +\label{sec:while} + +\syntax\begin{lstlisting} + Expr1 ::= `while' `(' Expr ')' {nl} Expr +\end{lstlisting} + +The while loop expression ~\lstinline@while ($e_1$) $e_2$@~ is typed and +evaluated as if it was an application of ~\lstinline@whileLoop ($e_1$) ($e_2$)@~ where +the hypothetical function \code{whileLoop} is defined as follows. + +\begin{lstlisting} + def whileLoop(cond: => Boolean)(body: => Unit): Unit = + if (cond) { body ; whileLoop(cond)(body) } else {} +\end{lstlisting} + +\comment{ +\example The loop +\begin{lstlisting} + while (x != 0) { y = y + 1/x ; x -= 1 } +\end{lstlisting} +Is equivalent to the application +\begin{lstlisting} + whileLoop (x != 0) { y = y + 1/x ; x -= 1 } +\end{lstlisting} +Note that this application will never produce a division-by-zero +error at run-time, since the +expression ~\lstinline@(y = 1/x)@~ will be evaluated in the body of +\code{while} only if the condition parameter is false. +} + +\section{Do Loop Expressions} + +\syntax\begin{lstlisting} + Expr1 ::= `do' Expr [semi] `while' `(' Expr ')' +\end{lstlisting} + +The do loop expression ~\lstinline@do $e_1$ while ($e_2$)@~ is typed and +evaluated as if it was the expression ~\lstinline@($e_1$ ; while ($e_2$) $e_1$)@. +A semicolon preceding the \code{while} symbol of a do loop expression is ignored. + + +For Comprehensions and For Loops +-------------------------------- + +\label{sec:for-comprehensions} + +\syntax\begin{lstlisting} + Expr1 ::= `for' (`(' Enumerators `)' | `{' Enumerators `}') + {nl} [`yield'] Expr + Enumerators ::= Generator {semi Enumerator} + Enumerator ::= Generator + | Guard + | `val' Pattern1 `=' Expr + Generator ::= Pattern1 `<-' Expr [Guard] + Guard ::= `if' PostfixExpr +\end{lstlisting} + +A for loop ~\lstinline@for ($\enums\,$) $e$@~ executes expression $e$ +for each binding generated by the enumerators $\enums$. A for +comprehension ~\lstinline@for ($\enums\,$) yield $e$@~ evaluates +expression $e$ for each binding generated by the enumerators $\enums$ +and collects the results. An enumerator sequence always starts with a +generator; this can be followed by further generators, value +definitions, or guards. A {\em generator} ~\lstinline@$p$ <- $e$@~ +produces bindings from an expression $e$ which is matched in some way +against pattern $p$. A {\em value definition} ~\lstinline@$p$ = $e$@~ +binds the value name $p$ (or several names in a pattern $p$) to +the result of evaluating the expression $e$. A {\em guard} +~\lstinline@if $e$@ contains a boolean expression which restricts +enumerated bindings. The precise meaning of generators and guards is +defined by translation to invocations of four methods: \code{map}, +\code{withFilter}, \code{flatMap}, and \code{foreach}. These methods can +be implemented in different ways for different carrier types. +\comment{As an example, an implementation of these methods for lists + is given in \sref{cls-list}.} + +The translation scheme is as follows. In a first step, every +generator ~\lstinline@$p$ <- $e$@, where $p$ is not irrefutable (\sref{sec:patterns}) +for the type of $e$ is replaced by +\begin{lstlisting} +$p$ <- $e$.withFilter { case $p$ => true; case _ => false } +\end{lstlisting} + +Then, the following rules are applied repeatedly until all +comprehensions have been eliminated. +\begin{itemize} +\item +A for comprehension +~\lstinline@for ($p$ <- $e\,$) yield $e'$@~ +is translated to +~\lstinline@$e$.map { case $p$ => $e'$ }@. + +\item +A for loop +~\lstinline@for ($p$ <- $e\,$) $e'$@~ +is translated to +~\lstinline@$e$.foreach { case $p$ => $e'$ }@. + +\item +A for comprehension +\begin{lstlisting} +for ($p$ <- $e$; $p'$ <- $e'; \ldots$) yield $e''$ , +\end{lstlisting} +where \lstinline@$\ldots$@ is a (possibly empty) +sequence of generators, definitions, or guards, +is translated to +\begin{lstlisting} +$e$.flatMap { case $p$ => for ($p'$ <- $e'; \ldots$) yield $e''$ } . +\end{lstlisting} +\item +A for loop +\begin{lstlisting} +for ($p$ <- $e$; $p'$ <- $e'; \ldots$) $e''$ . +\end{lstlisting} +where \lstinline@$\ldots$@ is a (possibly empty) +sequence of generators, definitions, or guards, +is translated to +\begin{lstlisting} +$e$.foreach { case $p$ => for ($p'$ <- $e'; \ldots$) $e''$ } . +\end{lstlisting} +\item +A generator ~\lstinline@$p$ <- $e$@~ followed by a guard +~\lstinline@if $g$@~ is translated to a single generator +~\lstinline@$p$ <- $e$.withFilter(($x_1 \commadots x_n$) => $g\,$)@~ where +$x_1 \commadots x_n$ are the free variables of $p$. +\item +A generator ~\lstinline@$p$ <- $e$@~ followed by a value definition +~\lstinline@$p'$ = $e'$@ is translated to the following generator of pairs of values, where +$x$ and $x'$ are fresh names: +\begin{lstlisting} +($p$, $p'$) <- for ($x @ p$ <- $e$) yield { val $x' @ p'$ = $e'$; ($x$, $x'$) } +\end{lstlisting} +\end{itemize} + +\example +The following code produces all pairs of numbers +between $1$ and $n-1$ whose sums are prime. +\begin{lstlisting} +for { i <- 1 until n + j <- 1 until i + if isPrime(i+j) +} yield (i, j) +\end{lstlisting} +The for comprehension is translated to: +\begin{lstlisting} +(1 until n) + .flatMap { + case i => (1 until i) + .withFilter { j => isPrime(i+j) } + .map { case j => (i, j) } } +\end{lstlisting} + +\comment{ +\example +\begin{lstlisting} +class List[A] { + def map[B](f: A => B): List[B] = match { + case <> => <> + case x :: xs => f(x) :: xs.map(f) + } + def withFilter(p: A => Boolean) = match { + case <> => <> + case x :: xs => if p(x) then x :: xs.withFilter(p) else xs.withFilter(p) + } + def flatMap[B](f: A => List[B]): List[B] = + if (isEmpty) Nil + else f(head) ::: tail.flatMap(f) + def foreach(f: A => Unit): Unit = + if (isEmpty) () + else (f(head); tail.foreach(f)) +} +\end{lstlisting} + +\example +\begin{lstlisting} +abstract class Graph[Node] { + type Edge = (Node, Node) + val nodes: List[Node] + val edges: List[Edge] + def succs(n: Node) = for ((p, s) <- g.edges, p == n) s + def preds(n: Node) = for ((p, s) <- g.edges, s == n) p +} +def topsort[Node](g: Graph[Node]): List[Node] = { + val sources = for (n <- g.nodes, g.preds(n) == <>) n + if (g.nodes.isEmpty) <> + else if (sources.isEmpty) new Error(``topsort of cyclic graph'') throw + else sources :+: topsort(new Graph[Node] { + val nodes = g.nodes diff sources + val edges = for ((p, s) <- g.edges, !(sources contains p)) (p, s) + }) +} +\end{lstlisting} +} + +\example For comprehensions can be used to express vector +and matrix algorithms concisely. +For instance, here is a function to compute the transpose of a given matrix: +% see test/files/run/t0421.scala +\begin{lstlisting} +def transpose[A](xss: Array[Array[A]]) = { + for (i <- Array.range(0, xss(0).length)) yield + for (xs <- xss) yield xs(i) +} +\end{lstlisting} + +Here is a function to compute the scalar product of two vectors: +\begin{lstlisting} +def scalprod(xs: Array[Double], ys: Array[Double]) = { + var acc = 0.0 + for ((x, y) <- xs zip ys) acc = acc + x * y + acc +} +\end{lstlisting} + +Finally, here is a function to compute the product of two matrices. +Compare with the imperative version of \ref{ex:imp-mat-mul}. +\begin{lstlisting} +def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = { + val ysst = transpose(yss) + for (xs <- xss) yield + for (yst <- ysst) yield + scalprod(xs, yst) +} +\end{lstlisting} +The code above makes use of the fact that \code{map}, \code{flatMap}, +\code{withFilter}, and \code{foreach} are defined for instances of class +\lstinline@scala.Array@. + +\section{Return Expressions} + +\syntax\begin{lstlisting} + Expr1 ::= `return' [Expr] +\end{lstlisting} + +A return expression ~\lstinline@return $e$@~ must occur inside the body of some +enclosing named method or function. The innermost enclosing named +method or function in a source program, $f$, must have an explicitly declared result type, +and the type of $e$ must conform to it. +The return expression +evaluates the expression $e$ and returns its value as the result of +$f$. The evaluation of any statements or +expressions following the return expression is omitted. The type of +a return expression is \code{scala.Nothing}. + +The expression $e$ may be omitted. The return expression +~\lstinline@return@~ is type-checked and evaluated as if it was ~\lstinline@return ()@. + +An \lstinline@apply@ method which is generated by the compiler as an +expansion of an anonymous function does not count as a named function +in the source program, and therefore is never the target of a return +expression. + +Returning from a nested anonymous function is implemented by throwing +and catching a \lstinline@scala.runtime.NonLocalReturnException@. Any +exception catches between the point of return and the enclosing +methods might see the exception. A key comparison makes sure that +these exceptions are only caught by the method instance which is +terminated by the return. + +If the return expression is itself part of an anonymous function, it +is possible that the enclosing instance of $f$ has already returned +before the return expression is executed. In that case, the thrown +\lstinline@scala.runtime.NonLocalReturnException@ will not be caught, +and will propagate up the call stack. + + + +\section{Throw Expressions} + +\syntax\begin{lstlisting} + Expr1 ::= `throw' Expr +\end{lstlisting} + +A throw expression ~\lstinline@throw $e$@~ evaluates the expression +$e$. The type of this expression must conform to +\code{Throwable}. If $e$ evaluates to an exception +reference, evaluation is aborted with the thrown exception. If $e$ +evaluates to \code{null}, evaluation is instead aborted with a +\code{NullPointerException}. If there is an active +\code{try} expression (\sref{sec:try}) which handles the thrown +exception, evaluation resumes with the handler; otherwise the thread +executing the \code{throw} is aborted. The type of a throw expression +is \code{scala.Nothing}. + +\section{Try Expressions}\label{sec:try} + +\syntax\begin{lstlisting} + Expr1 ::= `try' `{' Block `}' [`catch' `{' CaseClauses `}'] + [`finally' Expr] +\end{lstlisting} + +A try expression is of the form ~\lstinline@try { $b$ } catch $h$@~ +where the handler $h$ is a pattern matching anonymous function +(\sref{sec:pattern-closures}) +\begin{lstlisting} + { case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ } . +\end{lstlisting} +This expression is evaluated by evaluating the block +$b$. If evaluation of $b$ does not cause an exception to be +thrown, the result of $b$ is returned. Otherwise the +handler $h$ is applied to the thrown exception. +If the handler contains a case matching the thrown exception, +the first such case is invoked. If the handler contains +no case matching the thrown exception, the exception is +re-thrown. + +Let $\proto$ be the expected type of the try expression. The block +$b$ is expected to conform to $\proto$. The handler $h$ +is expected conform to type +~\lstinline@scala.PartialFunction[scala.Throwable, $\proto\,$]@. The +type of the try expression is the weak least upper bound (\sref{sec:weakconformance}) +of the type of $b$ +and the result type of $h$. + +A try expression ~\lstinline@try { $b$ } finally $e$@~ evaluates the block +$b$. If evaluation of $b$ does not cause an exception to be +thrown, the expression $e$ is evaluated. If an exception is thrown +during evaluation of $e$, the evaluation of the try expression is +aborted with the thrown exception. If no exception is thrown during +evaluation of $e$, the result of $b$ is returned as the +result of the try expression. + +If an exception is thrown during evaluation of $b$, the finally block +$e$ is also evaluated. If another exception $e$ is thrown +during evaluation of $e$, evaluation of the try expression is +aborted with the thrown exception. If no exception is thrown during +evaluation of $e$, the original exception thrown in $b$ is +re-thrown once evaluation of $e$ has completed. The block +$b$ is expected to conform to the expected type of the try +expression. The finally expression $e$ is expected to conform to +type \code{Unit}. + +A try expression ~\lstinline@try { $b$ } catch $e_1$ finally $e_2$@~ +is a shorthand +for ~\lstinline@try { try { $b$ } catch $e_1$ } finally $e_2$@. + +\section{Anonymous Functions} +\label{sec:closures} + +\syntax\begin{lstlisting} + Expr ::= (Bindings | [`implicit'] id | `_') `=>' Expr + ResultExpr ::= (Bindings | ([`implicit'] id | `_') `:' CompoundType) `=>' Block + Bindings ::= `(' Binding {`,' Binding} `)' + Binding ::= (id | `_') [`:' Type] +\end{lstlisting} + +The anonymous function ~\lstinline@($x_1$: $T_1 \commadots x_n$: $T_n$) => e@~ +maps parameters $x_i$ of types $T_i$ to a result given +by expression $e$. The scope of each formal parameter +$x_i$ is $e$. Formal parameters must have pairwise distinct names. + +If the expected type of the anonymous function is of the form +~\lstinline@scala.Function$n$[$S_1 \commadots S_n$, $R\,$]@, the +expected type of $e$ is $R$ and the type $T_i$ of any of the +parameters $x_i$ can be omitted, in which +case~\lstinline@$T_i$ = $S_i$@ is assumed. +If the expected type of the anonymous function is +some other type, all formal parameter types must be explicitly given, +and the expected type of $e$ is undefined. The type of the anonymous +function +is~\lstinline@scala.Function$n$[$S_1 \commadots S_n$, $T\,$]@, +where $T$ is the packed type (\sref{sec:expr-typing}) +of $e$. $T$ must be equivalent to a +type which does not refer to any of the formal parameters $x_i$. + +The anonymous function is evaluated as the instance creation expression +\begin{lstlisting} +new scala.Function$n$[$T_1 \commadots T_n$, $T$] { + def apply($x_1$: $T_1 \commadots x_n$: $T_n$): $T$ = $e$ +} +\end{lstlisting} +In the case of a single untyped formal parameter, +~\lstinline@($x\,$) => $e$@~ +can be abbreviated to ~\lstinline@$x$ => $e$@. If an +anonymous function ~\lstinline@($x$: $T\,$) => $e$@~ with a single +typed parameter appears as the result expression of a block, it can be +abbreviated to ~\lstinline@$x$: $T$ => e@. + +A formal parameter may also be a wildcard represented by an underscore \lstinline@_@. +In that case, a fresh name for the parameter is chosen arbitrarily. + +A named parameter of an anonymous function may be optionally preceded +by an \lstinline@implicit@ modifier. In that case the parameter is +labeled \lstinline@implicit@ (\sref{sec:implicits}); however the +parameter section itself does not count as an implicit parameter +section in the sense of (\sref{sec:impl-params}). Hence, arguments to +anonymous functions always have to be given explicitly. + +\example Examples of anonymous functions: + +\begin{lstlisting} + x => x // The identity function + + f => g => x => f(g(x)) // Curried function composition + + (x: Int,y: Int) => x + y // A summation function + + () => { count += 1; count } // The function which takes an + // empty parameter list $()$, + // increments a non-local variable + // `count' and returns the new value. + + _ => 5 // The function that ignores its argument + // and always returns 5. +\end{lstlisting} + +\subsection*{Placeholder Syntax for Anonymous Functions}\label{sec:impl-anon-fun} + +\syntax\begin{lstlisting} + SimpleExpr1 ::= `_' +\end{lstlisting} + +An expression (of syntactic category \lstinline@Expr@) +may contain embedded underscore symbols \code{_} at places where identifiers +are legal. Such an expression represents an anonymous function where subsequent +occurrences of underscores denote successive parameters. + +Define an {\em underscore section} to be an expression of the form +\lstinline@_:$T$@ where $T$ is a type, or else of the form \code{_}, +provided the underscore does not appear as the expression part of a +type ascription \lstinline@_:$T$@. + +An expression $e$ of syntactic category \code{Expr} {\em binds} an underscore section +$u$, if the following two conditions hold: (1) $e$ properly contains $u$, and +(2) there is no other expression of syntactic category \code{Expr} +which is properly contained in $e$ and which itself properly contains $u$. + +If an expression $e$ binds underscore sections $u_1 \commadots u_n$, in this order, it is equivalent to +the anonymous function ~\lstinline@($u'_1$, ... $u'_n$) => $e'$@~ +where each $u_i'$ results from $u_i$ by replacing the underscore with a fresh identifier and +$e'$ results from $e$ by replacing each underscore section $u_i$ by $u_i'$. + +\example The anonymous functions in the left column use placeholder +syntax. Each of these is equivalent to the anonymous function on its right. + +\begin{lstlisting} +_ + 1 x => x + 1 +_ * _ (x1, x2) => x1 * x2 +(_: Int) * 2 (x: Int) => (x: Int) * 2 +if (_) x else y z => if (z) x else y +_.map(f) x => x.map(f) +_.map(_ + 1) x => x.map(y => y + 1) +\end{lstlisting} + +\section{Constant Expressions}\label{sec:constant-expression} + +Constant expressions are expressions that the Scala compiler can evaluate to a constant. +The definition of ``constant expression'' depends on the platform, but they +include at least the expressions of the following forms: +\begin{itemize} +\item A literal of a value class, such as an integer +\item A string literal +\item A class constructed with \code{Predef.classOf} (\sref{cls:predef}) +\item An element of an enumeration from the underlying platform +\item A literal array, of the form + \lstinline^Array$(c_1 \commadots c_n)$^, + where all of the $c_i$'s are themselves constant expressions +\item An identifier defined by a constant value definition (\sref{sec:valdef}). +\end{itemize} + + +\section{Statements} +\label{sec:statements} + +\syntax\begin{lstlisting} + BlockStat ::= Import + | {Annotation} [`implicit'] Def + | {Annotation} {LocalModifier} TmplDef + | Expr1 + | + TemplateStat ::= Import + | {Annotation} {Modifier} Def + | {Annotation} {Modifier} Dcl + | Expr + | +\end{lstlisting} + +Statements occur as parts of blocks and templates. A statement can be +an import, a definition or an expression, or it can be empty. +Statements used in the template of a class definition can also be +declarations. An expression that is used as a statement can have an +arbitrary value type. An expression statement $e$ is evaluated by +evaluating $e$ and discarding the result of the evaluation. +\todo{Generalize to implicit coercion?} + +Block statements may be definitions which bind local names in the +block. The only modifier allowed in all block-local definitions is +\code{implicit}. When prefixing a class or object definition, +modifiers \code{abstract}, \code{final}, and \code{sealed} are also +permitted. + +Evaluation of a statement sequence entails evaluation of the +statements in the order they are written. + + +Implicit Conversions +-------------------- + +\label{sec:impl-conv} + +Implicit conversions can be applied to expressions whose type does not +match their expected type, to qualifiers in selections, and to unapplied methods. The +available implicit conversions are given in the next two sub-sections. + +We say, a type $T$ is {\em compatible} to a type $U$ if $T$ conforms +to $U$ after applying eta-expansion (\sref{sec:eta-expand}) and view applications +(\sref{sec:views}). + +\subsection{Value Conversions} + +The following five implicit conversions can be applied to an +expression $e$ which has some value type $T$ and which is type-checked with +some expected type $\proto$. + +\paragraph{\em Overloading Resolution} +If an expression denotes several possible members of a class, +overloading resolution (\sref{sec:overloading-resolution}) +is applied to pick a unique member. + +\paragraph{\em Type Instantiation} +An expression $e$ of polymorphic type +\begin{lstlisting} +[$a_1$ >: $L_1$ <: $U_1 \commadots a_n$ >: $L_n$ <: $U_n$]$T$ +\end{lstlisting} +which does not appear as the function part of +a type application is converted to a type instance of $T$ +by determining with local type inference +(\sref{sec:local-type-inf}) instance types ~\lstinline@$T_1 \commadots T_n$@~ +for the type variables ~\lstinline@$a_1 \commadots a_n$@~ and +implicitly embedding $e$ in the type application +~\lstinline@$e$[$T_1 \commadots T_n$]@~ (\sref{sec:type-app}). + +\paragraph{\em Numeric Widening} +If $e$ has a primitive number type which weakly conforms +(\sref{sec:weakconformance}) to the expected type, it is widened to +the expected type using one of the numeric conversion methods +\code{toShort}, \code{toChar}, \code{toInt}, \code{toLong}, +\code{toFloat}, \code{toDouble} defined in \sref{cls:numeric-value}. + +\paragraph{\em Numeric Literal Narrowing} +If the expected type is \code{Byte}, \code{Short} or \code{Char}, and +the expression $e$ is an integer literal fitting in the range of that +type, it is converted to the same literal in that type. + +\paragraph{\em Value Discarding} +If $e$ has some value type and the expected type is \code{Unit}, +$e$ is converted to the expected type by embedding it in the +term ~\lstinline@{ $e$; () }@. + +\paragraph{\em View Application} +If none of the previous conversions applies, and $e$'s type +does not conform to the expected type $\proto$, it is attempted to convert +$e$ to the expected type with a view (\sref{sec:views}).\bigskip + +\paragraph{\em Dynamic Member Selection} +If none of the previous conversions applies, and $e$ is a prefix +of a selection $e.x$, and $e$'s type conforms to class \code{scala.Dynamic}, +then the selection is rewritten according to the rules for dynamic +member selection (\sref{sec:dyn-mem-sel}). + +\subsection{Method Conversions} + +The following four implicit conversions can be applied to methods +which are not applied to some argument list. + +\paragraph{\em Evaluation} +A parameterless method $m$ of type \lstinline@=> $T$@ is always converted to +type $T$ by evaluating the expression to which $m$ is bound. + +\paragraph{\em Implicit Application} + If the method takes only implicit parameters, implicit + arguments are passed following the rules of \sref{sec:impl-params}. + +\paragraph{\em Eta Expansion} + Otherwise, if the method is not a constructor, + and the expected type $\proto$ is a function type + $(\Ts') \Arrow T'$, eta-expansion + (\sref{sec:eta-expand}) is performed on the + expression $e$. + +\paragraph{\em Empty Application} + Otherwise, if $e$ has method type $()T$, it is implicitly applied to the empty + argument list, yielding $e()$. + +\subsection{Overloading Resolution} +\label{sec:overloading-resolution} + +If an identifier or selection $e$ references several members of a +class, the context of the reference is used to identify a unique +member. The way this is done depends on whether or not $e$ is used as +a function. Let $\AA$ be the set of members referenced by $e$. + +Assume first that $e$ appears as a function in an application, as in +\lstinline@$e$($e_1 \commadots e_m$)@. + +One first determines the set of functions that is potentially +applicable based on the {\em shape} of the arguments. + +\newcommand{\shape}{\mbox{\sl shape}} + +The shape of an argument expression $e$, written $\shape(e)$, is +a type that is defined as follows: +\begin{itemize} +\item +For a function expression \lstinline@($p_1$: $T_1 \commadots p_n$: $T_n$) => $b$@: +\lstinline@(Any $\commadots$ Any) => $\shape(b)$@, where \lstinline@Any@ occurs $n$ times +in the argument type. +\item +For a named argument \lstinline@$n$ = $e$@: $\shape(e)$. +\item +For all other expressions: \lstinline@Nothing@. +\end{itemize} + +Let $\BB$ be the set of alternatives in $\AA$ that are {\em applicable} (\sref{sec:apply}) +to expressions $(e_1 \commadots e_n)$ of types +$(\shape(e_1) \commadots \shape(e_n))$. +If there is precisely one +alternative in $\BB$, that alternative is chosen. + +Otherwise, let $S_1 \commadots S_m$ be the vector of types obtained by +typing each argument with an undefined expected type. For every +member $m$ in $\BB$ one determines whether it is +applicable to expressions ($e_1 \commadots e_m$) of types $S_1 +\commadots S_m$. +It is an error if none of the members in $\BB$ is applicable. If there is one +single applicable alternative, that alternative is chosen. Otherwise, let $\CC$ +be the set of applicable alternatives which don't employ any default argument +in the application to $e_1 \commadots e_m$. It is again an error if $\CC$ is empty. +Otherwise, one chooses the {\em most specific} alternative among the alternatives +in $\CC$, according to the following definition of being ``as specific as'', and +``more specific than'': + +%% question: given +%% def f(x: Int) +%% val f: { def apply(x: Int) } +%% f(1) // the value is chosen in our current implementation + +%% why? +%% - method is as specific as value, because value is applicable to method's argument types (item 1) +%% - value is as specific as method (item 3, any other type is always as specific..) +%% so the method is not more specific than the value. + +\begin{itemize} +\item +A parameterized method $m$ of type \lstinline@($p_1:T_1\commadots p_n:T_n$)$U$@ is {\em as specific as} some other +member $m'$ of type $S$ if $m'$ is applicable to arguments +\lstinline@($p_1 \commadots p_n\,$)@ of +types $T_1 \commadots T_n$. +\item +A polymorphic method of type +~\lstinline@[$a_1$ >: $L_1$ <: $U_1 \commadots a_n$ >: $L_n$ <: $U_n$]$T$@~ is +as specific as some other member of type $S$ if $T$ is as +specific as $S$ under the assumption that for +$i = 1 \commadots n$ each $a_i$ is an abstract type name +bounded from below by $L_i$ and from above by $U_i$. +\item +A member of any other type is always as specific as a parameterized method +or a polymorphic method. +\item +Given two members of types $T$ and $U$ which are +neither parameterized nor polymorphic method types, the member of type $T$ is as specific as +the member of type $U$ if the existential dual of $T$ conforms to the existential dual of $U$. +Here, the existential dual of a polymorphic type +~\lstinline@[$a_1$ >: $L_1$ <: $U_1 \commadots a_n$ >: $L_n$ <: $U_n$]$T$@~ is +~\lstinline@$T$ forSome { type $a_1$ >: $L_1$ <: $U_1$ $\commadots$ type $a_n$ >: $L_n$ <: $U_n$}@. +The existential dual of every other type is the type itself. +\end{itemize} + +The {\em relative weight} of an alternative $A$ over an alternative $B$ is a +number from 0 to 2, defined as the sum of +\begin{itemize} +\item 1 if $A$ is as specific as $B$, 0 otherwise, and +\item 1 if $A$ is defined in a class or object which is derived + from the class or object defining $B$, 0 otherwise. +\end{itemize} +A class or object $C$ is {\em derived} from a class or object $D$ if one of +the following holds: +\begin{itemize} +\item $C$ is a subclass of $D$, or +\item $C$ is a companion object of a class derived from $D$, or +\item $D$ is a companion object of a class from which $C$ is derived. +\end{itemize} + +An alternative $A$ is {\em more specific} than an alternative $B$ if +the relative weight of $A$ over $B$ is greater than the relative +weight of $B$ over $A$. + +It is an error if there is no alternative in $\CC$ which is more +specific than all other alternatives in $\CC$. + +Assume next that $e$ appears as a function in a type application, as +in \lstinline@$e$[$\targs\,$]@. Then all alternatives in +$\AA$ which take the same number of type parameters as there are type +arguments in $\targs$ are chosen. It is an error if no such alternative exists. +If there are several such alternatives, overloading resolution is +applied again to the whole expression \lstinline@$e$[$\targs\,$]@. + +Assume finally that $e$ does not appear as a function in either +an application or a type application. If an expected type is given, +let $\BB$ be the set of those alternatives in $\AA$ which are +compatible (\sref{sec:impl-conv}) to it. Otherwise, let $\BB$ be the same as $\AA$. +We choose in this case the most specific alternative among all +alternatives in $\BB$. It is an error if there is no +alternative in $\BB$ which is more specific than all other +alternatives in $\BB$. + +\example Consider the following definitions: + +\begin{lstlisting} + class A extends B {} + def f(x: B, y: B) = $\ldots$ + def f(x: A, y: B) = $\ldots$ + val a: A + val b: B +\end{lstlisting} +Then the application \lstinline@f(b, b)@ refers to the first +definition of $f$ whereas the application \lstinline@f(a, a)@ +refers to the second. Assume now we add a third overloaded definition +\begin{lstlisting} + def f(x: B, y: A) = $\ldots$ +\end{lstlisting} +Then the application \lstinline@f(a, a)@ is rejected for being ambiguous, since +no most specific applicable signature exists. + +\subsection{Local Type Inference} +\label{sec:local-type-inf} + +Local type inference infers type arguments to be passed to expressions +of polymorphic type. Say $e$ is of type [$a_1$ >: $L_1$ <: $U_1 +\commadots a_n$ >: $L_n$ <: $U_n$]$T$ and no explicit type parameters +are given. + +Local type inference converts this expression to a type +application ~\lstinline@$e$[$T_1 \commadots T_n$]@. The choice of the +type arguments $T_1 \commadots T_n$ depends on the context in which +the expression appears and on the expected type $\proto$. +There are three cases. + +\paragraph{\em Case 1: Selections} +If the expression appears as the prefix of a selection with a name +$x$, then type inference is {\em deferred} to the whole expression +$e.x$. That is, if $e.x$ has type $S$, it is now treated as having +type [$a_1$ >: $L_1$ <: $U_1 \commadots a_n$ >: $L_n$ <: $U_n$]$S$, +and local type inference is applied in turn to infer type arguments +for $a_1 \commadots a_n$, using the context in which $e.x$ appears. + +\paragraph{\em Case 2: Values} +If the expression $e$ appears as a value without being applied to +value arguments, the type arguments are inferred by solving a +constraint system which relates the expression's type $T$ with the +expected type $\proto$. Without loss of generality we can assume that +$T$ is a value type; if it is a method type we apply eta-expansion +(\sref{sec:eta-expand}) to convert it to a function type. Solving +means finding a substitution $\sigma$ of types $T_i$ for the type +parameters $a_i$ such that +\begin{itemize} +\item +None of inferred types $T_i$ is a singleton type \sref{sec:singleton-types} +\item +All type parameter bounds are respected, i.e.\ +$\sigma L_i <: \sigma a_i$ and $\sigma a_i <: \sigma U_i$ for $i = 1 \commadots n$. +\item +The expression's type conforms to the expected type, i.e.\ +$\sigma T <: \sigma \proto$. +\end{itemize} +It is a compile time error if no such substitution exists. +If several substitutions exist, local-type inference will choose for +each type variable $a_i$ a minimal or maximal type $T_i$ of the +solution space. A {\em maximal} type $T_i$ will be chosen if the type +parameter $a_i$ appears contravariantly (\sref{sec:variances}) in the +type $T$ of the expression. A {\em minimal} type $T_i$ will be chosen +in all other situations, i.e.\ if the variable appears covariantly, +non-variantly or not at all in the type $T$. We call such a substitution +an {\em optimal solution} of the given constraint system for the type $T$. + +\paragraph{\em Case 3: Methods} The last case applies if the expression +$e$ appears in an application $e(d_1 \commadots d_m)$. In that case +$T$ is a method type $(p_1:R_1 \commadots p_m:R_m)T'$. Without loss of +generality we can assume that the result type $T'$ is a value type; if +it is a method type we apply eta-expansion (\sref{sec:eta-expand}) to +convert it to a function type. One computes first the types $S_j$ of +the argument expressions $d_j$, using two alternative schemes. Each +argument expression $d_j$ is typed first with the expected type $R_j$, +in which the type parameters $a_1 \commadots a_n$ are taken as type +constants. If this fails, the argument $d_j$ is typed instead with an +expected type $R_j'$ which results from $R_j$ by replacing every type +parameter in $a_1 \commadots a_n$ with {\sl undefined}. + +In a second step, type arguments are inferred by solving a constraint +system which relates the method's type with the expected type +$\proto$ and the argument types $S_1 \commadots S_m$. Solving the +constraint system means +finding a substitution $\sigma$ of types $T_i$ for the type parameters +$a_i$ such that +\begin{itemize} +\item +None of inferred types $T_i$ is a singleton type \sref{sec:singleton-types} +\item +All type parameter bounds are respected, i.e.\ +$\sigma L_i <: \sigma a_i$ and $\sigma a_i <: \sigma U_i$ for $i = 1 \commadots n$. +\item +The method's result type $T'$ conforms to the expected type, i.e.\ +$\sigma T' <: \sigma \proto$. +\item +Each argument type weakly conforms (\sref{sec:weakconformance}) +to the corresponding formal parameter +type, i.e.\ +$\sigma S_j \conforms_w \sigma R_j$ for $j = 1 \commadots m$. +\end{itemize} +It is a compile time error if no such substitution exists. If several +solutions exist, an optimal one for the type $T'$ is chosen. + +All or parts of an expected type $\proto$ may be undefined. The rules for +conformance (\sref{sec:conformance}) are extended to this case by adding +the rule that for any type $T$ the following two statements are always +true: +\[ + \mbox{\sl undefined} <: T \tab\mbox{and}\tab T <: \mbox{\sl undefined} . +\] + +It is possible that no minimal or maximal solution for a type variable +exists, in which case a compile-time error results. Because $<:$ is a +pre-order, it is also possible that a solution set has several optimal +solutions for a type. In that case, a Scala compiler is free to pick +any one of them. + +\example Consider the two methods: +\begin{lstlisting} +def cons[A](x: A, xs: List[A]): List[A] = x :: xs +def nil[B]: List[B] = Nil +\end{lstlisting} +and the definition +\begin{lstlisting} +val xs = cons(1, nil) . +\end{lstlisting} +The application of \code{cons} is typed with an undefined expected +type. This application is completed by local type inference to +~\lstinline@cons[Int](1, nil)@. +Here, one uses the following +reasoning to infer the type argument \lstinline@Int@ for the type +parameter \code{a}: + +First, the argument expressions are typed. The first argument \code{1} +has type \code{Int} whereas the second argument \lstinline@nil@ is +itself polymorphic. One tries to type-check \lstinline@nil@ with an +expected type \code{List[a]}. This leads to the constraint system +\begin{lstlisting} +List[b?] <: List[a] +\end{lstlisting} +where we have labeled \lstinline@b?@ with a question mark to indicate +that it is a variable in the constraint system. +Because class \lstinline@List@ is covariant, the optimal +solution of this constraint is +\begin{lstlisting} +b = scala.Nothing . +\end{lstlisting} + +In a second step, one solves the following constraint system for +the type parameter \code{a} of \code{cons}: +\begin{lstlisting} +Int <: a? +List[scala.Nothing] <: List[a?] +List[a?] <: $\mbox{\sl undefined}$ +\end{lstlisting} +The optimal solution of this constraint system is +\begin{lstlisting} +a = Int , +\end{lstlisting} +so \code{Int} is the type inferred for \code{a}. + +\example Consider now the definition +\begin{lstlisting} +val ys = cons("abc", xs) +\end{lstlisting} +where \code{xs} is defined of type \code{List[Int]} as before. +In this case local type inference proceeds as follows. + +First, the argument expressions are typed. The first argument +\code{"abc"} has type \code{String}. The second argument \code{xs} is +first tried to be typed with expected type \code{List[a]}. This fails, +as \code{List[Int]} is not a subtype of \code{List[a]}. Therefore, +the second strategy is tried; \code{xs} is now typed with expected type +\lstinline@List[$\mbox{\sl undefined}$]@. This succeeds and yields the argument type +\code{List[Int]}. + +In a second step, one solves the following constraint system for +the type parameter \code{a} of \code{cons}: +\begin{lstlisting} +String <: a? +List[Int] <: List[a?] +List[a?] <: $\mbox{\sl undefined}$ +\end{lstlisting} +The optimal solution of this constraint system is +\begin{lstlisting} +a = scala.Any , +\end{lstlisting} +so \code{scala.Any} is the type inferred for \code{a}. + +\subsection{Eta Expansion}\label{sec:eta-expand} + + {\em Eta-expansion} converts an expression of method type to an + equivalent expression of function type. It proceeds in two steps. + + First, one identifes the maximal sub-expressions of $e$; let's + say these are $e_1 \commadots e_m$. For each of these, one creates a + fresh name $x_i$. Let $e'$ be the expression resulting from + replacing every maximal subexpression $e_i$ in $e$ by the + corresponding fresh name $x_i$. Second, one creates a fresh name $y_i$ + for every argument type $T_i$ of the method ($i = 1 \commadots + n$). The result of eta-conversion is then: +\begin{lstlisting} + { val $x_1$ = $e_1$; + $\ldots$ + val $x_m$ = $e_m$; + ($y_1: T_1 \commadots y_n: T_n$) => $e'$($y_1 \commadots y_n$) + } +\end{lstlisting} + +\subsection{Dynamic Member Selection}\label{sec:dyn-mem-sel} + +The standard Scala library defines a trait \lstinline@scala.Dynamic@ which defines a member +\@invokeDynamic@ as follows: +\begin{lstlisting} +package scala +trait Dynamic { + def applyDynamic (name: String, args: Any*): Any + ... +} +\end{lstlisting} +Assume a selection of the form $e.x$ where the type of $e$ conforms to \lstinline@scala.Dynamic@. +Further assuming the selection is not followed by any function arguments, such an expression can be rewitten under the conditions given in \sref{sec:impl-conv} to: +\begin{lstlisting} +$e$.applyDynamic("$x$") +\end{lstlisting} +If the selection is followed by some arguments, e.g.\ $e.x(\args)$, then that expression +is rewritten to +\begin{lstlisting} +$e$.applyDynamic("$x$", $\args$) +\end{lstlisting} + diff --git a/09-implicit-parameters-and-views.md b/09-implicit-parameters-and-views.md new file mode 100644 index 000000000000..1caef761eddc --- /dev/null +++ b/09-implicit-parameters-and-views.md @@ -0,0 +1,419 @@ +Implicit Parameters and Views +============================= + +\section{The Implicit Modifier}\label{sec:impl-defs} + +\syntax\begin{lstlisting} + LocalModifier ::= `implicit' + ParamClauses ::= {ParamClause} [nl] `(' `implicit' Params `)' +\end{lstlisting} + +Template members and parameters labeled with an \code{implicit} +modifier can be passed to implicit parameters (\sref{sec:impl-params}) +and can be used as implicit conversions called views +(\sref{sec:views}). The \code{implicit} modifier is illegal for all +type members, as well as for top-level (\sref{sec:packagings}) +objects. + +\example\label{ex:impl-monoid} +The following code defines an abstract class of monoids and +two concrete implementations, \code{StringMonoid} and +\code{IntMonoid}. The two implementations are marked implicit. + +\begin{lstlisting} +abstract class Monoid[A] extends SemiGroup[A] { + def unit: A + def add(x: A, y: A): A +} +object Monoids { + implicit object stringMonoid extends Monoid[String] { + def add(x: String, y: String): String = x.concat(y) + def unit: String = "" + } + implicit object intMonoid extends Monoid[Int] { + def add(x: Int, y: Int): Int = x + y + def unit: Int = 0 + } +} +\end{lstlisting} + +\section{Implicit Parameters}\label{sec:impl-params} + +An implicit parameter list +~\lstinline@(implicit $p_1$,$\ldots$,$p_n$)@~ of a method marks the parameters $p_1 \commadots p_n$ as +implicit. A method or constructor can have only one implicit parameter +list, and it must be the last parameter list given. + +A method with implicit parameters can be applied to arguments just +like a normal method. In this case the \code{implicit} label has no +effect. However, if such a method misses arguments for its implicit +parameters, such arguments will be automatically provided. + +The actual arguments that are eligible to be passed to an implicit +parameter of type $T$ fall into two categories. First, eligible are +all identifiers $x$ that can be accessed at the point of the method +call without a prefix and that denote an implicit definition +(\sref{sec:impl-defs}) or an implicit parameter. An eligible +identifier may thus be a local name, or a member of an enclosing +template, or it may be have been made accessible without a prefix +through an import clause (\sref{sec:import}). If there are no eligible +identifiers under this rule, then, second, eligible are also all +\code{implicit} members of some object that belongs to the implicit +scope of the implicit parameter's type, $T$. + +The {\em implicit scope} of a type $T$ consists of all companion modules +(\sref{sec:object-defs}) of classes that are associated with the +implicit parameter's type. Here, we say a class $C$ is {\em +associated} with a type $T$, if it is a base class +(\sref{sec:linearization}) of some part of $T$. The {\em parts} of a +type $T$ are: +\begin{itemize} +\item +if $T$ is a compound type ~\lstinline@$T_1$ with $\ldots$ with $T_n$@, the +union of the parts of $T_1 \commadots T_n$, as well as $T$ itself, +\item +if $T$ is a parameterized type ~\lstinline@$S$[$T_1 \commadots T_n$]@, +the union of the parts of $S$ and $T_1 \commadots T_n$, +\item +if $T$ is a singleton type ~\lstinline@$p$.type@, the parts of the type +of $p$, +\item +if $T$ is a type projection ~\lstinline@$S$#$U$@, the parts of $S$ as +well as $T$ itself, +\item +in all other cases, just $T$ itself. +\end{itemize} + +If there are several eligible arguments which match the implicit +parameter's type, a most specific one will be chosen using the rules +of static overloading resolution (\sref{sec:overloading-resolution}). +If the parameter has a default argument and no implicit argument can +be found the default argument is used. + +\example Assuming the classes from \ref{ex:impl-monoid}, here is a +method which computes the sum of a list of elements using the +monoid's \code{add} and \code{unit} operations. +\begin{lstlisting} +def sum[A](xs: List[A])(implicit m: Monoid[A]): A = + if (xs.isEmpty) m.unit + else m.add(xs.head, sum(xs.tail)) +\end{lstlisting} +The monoid in question is marked as an implicit parameter, and can therefore +be inferred based on the type of the list. +Consider for instance the call +\begin{lstlisting} + sum(List(1, 2, 3)) +\end{lstlisting} +in a context where \lstinline@stringMonoid@ and \lstinline@intMonoid@ +are visible. We know that the formal type parameter \lstinline@a@ of +\lstinline@sum@ needs to be instantiated to \lstinline@Int@. The only +eligible object which matches the implicit formal parameter type +\lstinline@Monoid[Int]@ is \lstinline@intMonoid@ so this object will +be passed as implicit parameter.\bigskip + +This discussion also shows that implicit parameters are inferred after +any type arguments are inferred (\sref{sec:local-type-inf}). + +Implicit methods can themselves have implicit parameters. An example +is the following method from module \code{scala.List}, which injects +lists into the \lstinline@scala.Ordered@ class, provided the element +type of the list is also convertible to this type. +\begin{lstlisting} +implicit def list2ordered[A](x: List[A]) + (implicit elem2ordered: A => Ordered[A]): Ordered[List[A]] = + ... +\end{lstlisting} +Assume in addition a method +\begin{lstlisting} +implicit def int2ordered(x: Int): Ordered[Int] +\end{lstlisting} +that injects integers into the \lstinline@Ordered@ class. We can now +define a \code{sort} method over ordered lists: +\begin{lstlisting} +def sort[A](xs: List[A])(implicit a2ordered: A => Ordered[A]) = ... +\end{lstlisting} +We can apply \code{sort} to a list of lists of integers ~\lstinline@yss: List[List[Int]]@~ +as follows: +\begin{lstlisting} +sort(yss) +\end{lstlisting} +The call above will be completed by passing two nested implicit arguments: +\begin{lstlisting} +sort(yss)(xs: List[Int] => list2ordered[Int](xs)(int2ordered)) . +\end{lstlisting} +The possibility of passing implicit arguments to implicit arguments +raises the possibility of an infinite recursion. For instance, one +might try to define the following method, which injects {\em every} type into the \lstinline@Ordered@ class: +\begin{lstlisting} +implicit def magic[A](x: A)(implicit a2ordered: A => Ordered[A]): Ordered[A] = + a2ordered(x) +\end{lstlisting} +Now, if one tried to apply +\lstinline@sort@ to an argument \code{arg} of a type that did not have +another injection into the \code{Ordered} class, one would obtain an infinite +expansion: +\begin{lstlisting} +sort(arg)(x => magic(x)(x => magic(x)(x => ... ))) +\end{lstlisting} +To prevent such infinite expansions, the compiler keeps track of +a stack of ``open implicit types'' for which implicit arguments are currently being +searched. Whenever an implicit argument for type $T$ is searched, the +``core type'' of $T$ is added to the stack. Here, the {\em core type} +of $T$ is $T$ with aliases expanded, top-level type annotations (\sref{sec:annotations}) and +refinements (\sref{sec:refinements}) removed, and occurrences +of top-level existentially bound variables replaced by their upper +bounds. The core type is removed from the stack once the search for +the implicit argument either definitely fails or succeeds. Everytime a +core type is added to the stack, it is checked that this type does not +dominate any of the other types in the set. + +Here, a core type $T$ {\em dominates} a type $U$ if $T$ is equivalent (\sref{sec:type-equiv}) +to $U$, or if the top-level type constructors of $T$ and $U$ have a +common element and $T$ is more complex than $U$. + +The set of {\em top-level type constructors} $\ttcs(T)$ of a type $T$ depends on the form of +the type: +\begin{quote} +For a type designator, \\ +$\ttcs(p.c) ~=~ \{c\}$; \\ +For a parameterized type, \\ +$\ttcs(p.c[\targs]) ~=~ \{c\}$; \\ +For a singleton type, \\ +$\ttcs(p.type) ~=~ \ttcs(T)$, provided $p$ has type $T$;\\ +For a compound type, \\ +\lstinline@$\ttcs(T_1$ with $\ldots$ with $T_n)$@ $~=~ \ttcs(T_1) \cup \ldots \cup \ttcs(T_n)$. +\end{quote} + +The {\em complexity} $\complx(T)$ of a core type is an integer which also depends on the form of +the type: +\begin{quote} +For a type designator, \\ +$\complx(p.c) ~=~ 1 + \complx(p)$ \\ +For a parameterized type, \\ +$\complx(p.c[\targs]) ~=~ 1 + \Sigma \complx(\targs)$ \\ +For a singleton type denoting a package $p$, \\ +$\complx(p.type) ~=~ 0$ \\ +For any other singleton type, \\ +$\complx(p.type) ~=~ 1 + \complx(T)$, provided $p$ has type $T$;\\ +For a compound type, \\ +\lstinline@$\complx(T_1$ with $\ldots$ with $T_n)$@ $= \Sigma\complx(T_i)$ +\end{quote} + +\example When typing \code{sort(xs)} for some list \code{xs} of type \code{List[List[List[Int]]]}, +the sequence of types for +which implicit arguments are searched is +\begin{lstlisting} +List[List[Int]] => Ordered[List[List[Int]]], +List[Int] => Ordered[List[Int]] +Int => Ordered[Int] +\end{lstlisting} +All types share the common type constructor \code{scala.Function1}, +but the complexity of the each new type is lower than the complexity of the previous types. +Hence, the code typechecks. + +\example Let \code{ys} be a list of some type which cannot be converted +to \code{Ordered}. For instance: +\begin{lstlisting} +val ys = List(new IllegalArgumentException, new ClassCastException, new Error) +\end{lstlisting} +Assume that the definition of \code{magic} above is in scope. Then the sequence +of types for which implicit arguments are searched is +\begin{lstlisting} +Throwable => Ordered[Throwable], +Throwable => Ordered[Throwable], +... +\end{lstlisting} +Since the second type in the sequence is equal to the first, the compiler +will issue an error signalling a divergent implicit expansion. + +\section{Views}\label{sec:views} + +Implicit parameters and methods can also define implicit conversions +called views. A {\em view} from type $S$ to type $T$ is +defined by an implicit value which has function type +\lstinline@$S$=>$T$@ or \lstinline@(=>$S$)=>$T$@ or by a method convertible to a value of that +type. + +Views are applied in three situations. +\begin{enumerate} +\item +If an expression $e$ is of type $T$, and $T$ does not conform to the +expression's expected type $\proto$. In this case an implicit $v$ is +searched which is applicable to $e$ and whose result type conforms to +$\proto$. The search proceeds as in the case of implicit parameters, +where the implicit scope is the one of ~\lstinline@$T$ => $\proto$@. If +such a view is found, the expression $e$ is converted to +\lstinline@$v$($e$)@. +\item +In a selection $e.m$ with $e$ of type $T$, if the selector $m$ does +not denote a member of $T$. In this case, a view $v$ is searched +which is applicable to $e$ and whose result contains a member named +$m$. The search proceeds as in the case of implicit parameters, where +the implicit scope is the one of $T$. If such a view is found, the +selection $e.m$ is converted to \lstinline@$v$($e$).$m$@. +\item +In a selection $e.m(\args)$ with $e$ of type $T$, if the selector +$m$ denotes some member(s) of $T$, but none of these members is applicable to the arguments +$\args$. In this case a view $v$ is searched which is applicable to $e$ +and whose result contains a method $m$ which is applicable to $\args$. +The search proceeds as in the case of implicit parameters, where +the implicit scope is the one of $T$. If such a view is found, the +selection $e.m$ is converted to \lstinline@$v$($e$).$m(\args)$@. +\end{enumerate} +The implicit view, if it is found, can accept is argument $e$ as a +call-by-value or as a call-by-name parameter. However, call-by-value +implicits take precedence over call-by-name implicits. + +As for implicit parameters, overloading resolution is applied +if there are several possible candidates (of either the call-by-value +or the call-by-name category). + +\example\label{ex:impl-ordered} Class \lstinline@scala.Ordered[A]@ contains a method +\begin{lstlisting} + def <= [B >: A](that: B)(implicit b2ordered: B => Ordered[B]): Boolean . +\end{lstlisting} +Assume two lists \code{xs} and \code{ys} of type \code{List[Int]} +and assume that the \code{list2ordered} and \code{int2ordered} +methods defined in \sref{sec:impl-params} are in scope. +Then the operation +\begin{lstlisting} + xs <= ys +\end{lstlisting} +is legal, and is expanded to: +\begin{lstlisting} + list2ordered(xs)(int2ordered).<= + (ys) + (xs => list2ordered(xs)(int2ordered)) +\end{lstlisting} +The first application of \lstinline@list2ordered@ converts the list +\code{xs} to an instance of class \code{Ordered}, whereas the second +occurrence is part of an implicit parameter passed to the \code{<=} +method. + +\section{Context Bounds and View Bounds}\label{sec:context-bounds} + +\syntax\begin{lstlisting} + TypeParam ::= (id | `_') [TypeParamClause] [`>:' Type] [`<:'Type] + {`<%' Type} {`:' Type} +\end{lstlisting} + +A type parameter $A$ of a method or non-trait class may have one or more view +bounds \lstinline@$A$ <% $T$@. In this case the type parameter may be +instantiated to any type $S$ which is convertible by application of a +view to the bound $T$. + +A type parameter $A$ of a method or non-trait class may also have one +or more context bounds \lstinline@$A$ : $T$@. In this case the type parameter may be +instantiated to any type $S$ for which {\em evidence} exists at the +instantiation point that $S$ satisfies the bound $T$. Such evidence +consists of an implicit value with type $T[S]$. + +A method or class containing type parameters with view or context bounds is treated as being +equivalent to a method with implicit parameters. Consider first the case of a +single parameter with view and/or context bounds such as: +\begin{lstlisting} +def $f$[$A$ <% $T_1$ ... <% $T_m$ : $U_1$ : $U_n$]($\ps$): $R$ = ... +\end{lstlisting} +Then the method definition above is expanded to +\begin{lstlisting} +def $f$[$A$]($\ps$)(implicit $v_1$: $A$ => $T_1$, ..., $v_m$: $A$ => $T_m$, + $w_1$: $U_1$[$A$], ..., $w_n$: $U_n$[$A$]): $R$ = ... +\end{lstlisting} +where the $v_i$ and $w_j$ are fresh names for the newly introduced implicit parameters. These +parameters are called {\em evidence parameters}. + +If a class or method has several view- or context-bounded type parameters, each +such type parameter is expanded into evidence parameters in the order +they appear and all the resulting evidence parameters are concatenated +in one implicit parameter section. Since traits do not take +constructor parameters, this translation does not work for them. +Consequently, type-parameters in traits may not be view- or context-bounded. +Also, a method or class with view- or context bounds may not define any +additional implicit parameters. + +\example The \code{<=} method mentioned in \ref{ex:impl-ordered} can be declared +more concisely as follows: +\begin{lstlisting} + def <= [B >: A <% Ordered[B]](that: B): Boolean +\end{lstlisting} + +\section{Manifests}\label{sec:manifests} + +\newcommand{\Mobj}{\mbox{\sl Mobj}} + +Manifests are type descriptors that can be automatically generated by +the Scala compiler as arguments to implicit parameters. The Scala +standard library contains a hierarchy of four manifest classes, +with \lstinline@OptManifest@ +at the top. Their signatures follow the outline below. +\begin{lstlisting} +trait OptManifest[+T] +object NoManifest extends OptManifest[Nothing] +trait ClassManifest[T] extends OptManifest[T] +trait Manifest[T] extends ClassManifest[T] +\end{lstlisting} + +If an implicit parameter of a method or constructor is of a subtype $M[T]$ of +class \lstinline@OptManifest[T]@, {\em a manifest is determined for $M[S]$}, +according to the following rules. + +First if there is already an implicit argument that matches $M[T]$, this +argument is selected. + +Otherwise, let $\Mobj$ be the companion object \lstinline@scala.reflect.Manifest@ +if $M$ is trait \lstinline@Manifest@, or be +the companion object \lstinline@scala.reflect.ClassManifest@ otherwise. Let $M'$ be the trait +\lstinline@Manifest@ if $M$ is trait \lstinline@Manifest@, or be the trait \lstinline@OptManifest@ otherwise. +Then the following rules apply. + + +\begin{enumerate} +\item +If $T$ is a value class or one of the classes \lstinline@Any@, \lstinline@AnyVal@, \lstinline@Object@, +\lstinline@Null@, or \lstinline@Nothing@, +a manifest for it is generated by selecting +the corresponding manifest value \lstinline@Manifest.$T$@, which exists in the +\lstinline@Manifest@ module. +\item +If $T$ is an instance of \lstinline@Array[$S$]@, a manifest is generated +with the invocation \lstinline@$\Mobj$.arrayType[S](m)@, where $m$ is the manifest +determined for $M[S]$. +\item +If $T$ is some other class type $S\#C[U_1 \commadots U_n]$ where the prefix type $S$ +cannot be statically determined from the class $C$, +a manifest is generated +with the invocation \lstinline@$\Mobj$.classType[T]($m_0$, classOf[T], $ms$)@ +where $m_0$ is the manifest determined for $M'[S]$ and $ms$ are the +manifests determined for $M'[U_1] \commadots M'[U_n]$. +\item +If $T$ is some other class type with type arguments $U_1 \commadots U_n$, +a manifest is generated +with the invocation \lstinline@$\Mobj$.classType[T](classOf[T], $ms$)@ +where $ms$ are the +manifests determined for $M'[U_1] \commadots M'[U_n]$. +\item +If $T$ is a singleton type ~\lstinline@$p$.type@, a manifest is generated with +the invocation +\lstinline@$\Mobj$.singleType[T]($p$)@ +\item +If $T$ is a refined type $T' \{ R \}$, a manifest is generated for $T'$. +(That is, refinements are never reflected in manifests). +\item +If $T$ is an intersection type +\lstinline@$T_1$ with $\commadots$ with $T_n$@ +where $n > 1$, the result depends on whether a full manifest is +to be determined or not. +If $M$ is trait \lstinline@Manifest@, then +a manifest is generated with the invocation +\lstinline@Manifest.intersectionType[T]($ms$)@ where $ms$ are the manifests +determined for $M[T_1] \commadots M[T_n]$. +Otherwise, if $M$ is trait \lstinline@ClassManifest@, +then a manifest is generated for the intersection dominator +(\sref{sec:erasure}) +of the types $T_1 \commadots T_n$. +\item +If $T$ is some other type, then if $M$ is trait \lstinline@OptManifest@, +a manifest is generated from the designator \lstinline@scala.reflect.NoManifest@. +If $M$ is a type different from \lstinline@OptManifest@, a static error results. +\end{enumerate} + diff --git a/10-pattern-matching.md b/10-pattern-matching.md new file mode 100644 index 000000000000..5c73006f1122 --- /dev/null +++ b/10-pattern-matching.md @@ -0,0 +1,846 @@ +Pattern Matching +================ + +\section{Patterns} + +\label{sec:patterns} + +\syntax\begin{lstlisting} + Pattern ::= Pattern1 { `|' Pattern1 } + Pattern1 ::= varid `:' TypePat + | `_' `:' TypePat + | Pattern2 + Pattern2 ::= varid [`@' Pattern3] + | Pattern3 + Pattern3 ::= SimplePattern + | SimplePattern {id [nl] SimplePattern} + SimplePattern ::= `_' + | varid + | Literal + | StableId + | StableId `(' [Patterns] `)' + | StableId `(' [Patterns `,'] [varid `@'] `_' `*' `)' + | `(' [Patterns] `)' + | XmlPattern + Patterns ::= Pattern {`,' Patterns} +\end{lstlisting} + +%For clarity, this section deals with a subset of the Scala pattern language. +%The extended Scala pattern language, which is described below, adds more +%flexible variable binding and regular hedge expressions. + +A pattern is built from constants, constructors, variables and type +tests. Pattern matching tests whether a given value (or sequence of values) +has the shape defined by a pattern, and, if it does, binds the +variables in the pattern to the corresponding components of the value +(or sequence of values). The same variable name may not be bound more +than once in a pattern. + +\example Some examples of patterns are: +\begin{enumerate} +\item +The pattern ~\lstinline@ex: IOException@ matches all instances of class +\lstinline@IOException@, binding variable \verb@ex@ to the instance. +\item +The pattern ~\lstinline@Some(x)@~ matches values of the form ~\lstinline@Some($v$)@, +binding \lstinline@x@ to the argument value $v$ of the \code{Some} constructor. +\item +The pattern ~\lstinline@(x, _)@~ matches pairs of values, binding \lstinline@x@ to +the first component of the pair. The second component is matched +with a wildcard pattern. +\item +The pattern ~\lstinline@x :: y :: xs@~ matches lists of length $\geq 2$, +binding \lstinline@x@ to the list's first element, \lstinline@y@ to the list's +second element, and \lstinline@xs@ to the remainder. +\item +The pattern ~\lstinline@1 | 2 | 3@~ matches the integers between 1 and 3. +\end{enumerate} + +Pattern matching is always done in a context which supplies an +expected type of the pattern. We distinguish the following kinds of +patterns. + +\subsection{Variable Patterns} + +\syntax\begin{lstlisting} + SimplePattern ::= `_' + | varid +\end{lstlisting} + +A variable pattern $x$ is a simple identifier which starts with a +lower case letter. It matches any value, and binds the variable name +to that value. The type of $x$ is the expected type of the pattern as +given from outside. A special case is the wild-card pattern $\_$ +which is treated as if it was a fresh variable on each occurrence. + +\subsection{Typed Patterns} +\label{sec:typed-patterns} +\syntax +\begin{lstlisting} + Pattern1 ::= varid `:' TypePat + | `_' `:' TypePat +\end{lstlisting} + +A typed pattern $x: T$ consists of a pattern variable $x$ and a +type pattern $T$. The type of $x$ is the type pattern $T$, where +each type variable and wildcard is replaced by a fresh, unknown type. +This pattern matches any value matched by the type +pattern $T$ (\sref{sec:type-patterns}); it binds the variable name to +that value. + +\subsection{Pattern Binders} +\label{sec:pattern-binders} +\syntax +\begin{lstlisting} + Pattern2 ::= varid `@' Pattern3 +\end{lstlisting} +A pattern binder \lstinline|$x$@$p$| consists of a pattern variable $x$ and a +pattern $p$. The type of the variable $x$ is the static type $T$ of the pattern $p$. +This pattern matches any value $v$ matched by the pattern $p$, +provided the run-time type of $v$ is also an instance of $T$, +and it binds the variable name to that value. + +\subsection{Literal Patterns} + +\syntax\begin{lstlisting} + SimplePattern ::= Literal +\end{lstlisting} + +A literal pattern $L$ matches any value that is equal (in terms of +$==$) to the literal $L$. The type of $L$ must conform to the +expected type of the pattern. + +\subsection{Stable Identifier Patterns} + +\syntax +\begin{lstlisting} + SimplePattern ::= StableId +\end{lstlisting} + +A stable identifier pattern is a stable identifier $r$ +(\sref{sec:stable-ids}). The type of $r$ must conform to the expected +type of the pattern. The pattern matches any value $v$ such that +~\lstinline@$r$ == $v$@~ (\sref{sec:cls-object}). + +To resolve the syntactic overlap with a variable pattern, a +stable identifier pattern may not be a simple name starting with a lower-case +letter. However, it is possible to enclose a such a variable name in +backquotes; then it is treated as a stable identifier pattern. + +\example Consider the following function definition: +\begin{lstlisting} +def f(x: Int, y: Int) = x match { + case y => ... +} +\end{lstlisting} +Here, \lstinline@y@ is a variable pattern, which matches any value. +If we wanted to turn the pattern into a stable identifier pattern, this +can be achieved as follows: +\begin{lstlisting} +def f(x: Int, y: Int) = x match { + case `y` => ... +} +\end{lstlisting} +Now, the pattern matches the \code{y} parameter of the enclosing function \code{f}. +That is, the match succeeds only if the \code{x} argument and the \code{y} +argument of \code{f} are equal. + +\subsection{Constructor Patterns} + +\syntax\begin{lstlisting} + SimplePattern ::= StableId `(' [Patterns] `) +\end{lstlisting} + +A constructor pattern is of the form $c(p_1 \commadots p_n)$ where $n +\geq 0$. It consists of a stable identifier $c$, followed by element +patterns $p_1 \commadots p_n$. The constructor $c$ is a simple or +qualified name which denotes a case class +(\sref{sec:case-classes}). If the case class is monomorphic, then it +must conform to the expected type of the pattern, and the formal +parameter types of $x$'s primary constructor (\sref{sec:class-defs}) +are taken as the expected types of the element patterns $p_1\commadots +p_n$. If the case class is polymorphic, then its type parameters are +instantiated so that the instantiation of $c$ conforms to the expected +type of the pattern. The instantiated formal parameter types of $c$'s +primary constructor are then taken as the expected types of the +component patterns $p_1\commadots p_n$. The pattern matches all +objects created from constructor invocations $c(v_1 \commadots v_n)$ +where each element pattern $p_i$ matches the corresponding value +$v_i$. + +A special case arises when $c$'s formal parameter types end in a +repeated parameter. This is further discussed in +(\sref{sec:pattern-seqs}). + +\subsection{Tuple Patterns} + +\syntax\begin{lstlisting} + SimplePattern ::= `(' [Patterns] `)' +\end{lstlisting} + +A tuple pattern \lstinline@($p_1 \commadots p_n$)@ is an alias +for the constructor pattern ~\lstinline@scala.Tuple$n$($p_1 \commadots +p_n$)@, where $n \geq 2$. The empty tuple +\lstinline@()@ is the unique value of type \lstinline@scala.Unit@. + +\subsection{Extractor Patterns}\label{sec:extractor-patterns} + +\syntax\begin{lstlisting} + SimplePattern ::= StableId `(' [Patterns] `)' +\end{lstlisting} + +An extractor pattern $x(p_1 \commadots p_n)$ where $n \geq 0$ is of +the same syntactic form as a constructor pattern. However, instead of +a case class, the stable identifier $x$ denotes an object which has a +member method named \code{unapply} or \code{unapplySeq} that matches +the pattern. + +An \code{unapply} method in an object $x$ {\em matches} the pattern +$x(p_1 \commadots p_n)$ if it takes exactly one argument and one of +the following applies: +\begin{itemize} +\item[] +$n=0$ and \code{unapply}'s result type is \code{Boolean}. In this case +the extractor pattern matches all values $v$ for which +\lstinline@$x$.unapply($v$)@ yields \code{true}. +\item[] +$n=1$ and \code{unapply}'s result type is \lstinline@Option[$T$]@, for some +type $T$. In this case, the (only) argument pattern $p_1$ is typed in +turn with expected type $T$. The extractor pattern matches then all +values $v$ for which \lstinline@$x$.unapply($v$)@ yields a value of form +\lstinline@Some($v_1$)@, and $p_1$ matches $v_1$. +\item[] +$n>1$ and \code{unapply}'s result type is +\lstinline@Option[($T_1 \commadots T_n$)]@, for some +types $T_1 \commadots T_n$. In this case, the argument patterns $p_1 +\commadots p_n$ are typed in turn with expected types $T_1 \commadots +T_n$. The extractor pattern matches then all values $v$ for which +\lstinline@$x$.unapply($v$)@ yields a value of form +\lstinline@Some(($v_1 \commadots v_n$))@, and each pattern +$p_i$ matches the corresponding value $v_i$. +\end{itemize} + +An \code{unapplySeq} method in an object $x$ matches the pattern +$x(p_1 \commadots p_n)$ if it takes exactly one argument and its +result type is of the form \lstinline@Option[$S$]@, where $S$ is a subtype of +\lstinline@Seq[$T$]@ for some element type $T$. +This case is further discussed in (\sref{sec:pattern-seqs}). + +\example The \code{Predef} object contains a definition of an +extractor object \code{Pair}: +\begin{lstlisting} +object Pair { + def apply[A, B](x: A, y: B) = Tuple2(x, y) + def unapply[A, B](x: Tuple2[A, B]): Option[Tuple2[A, B]] = Some(x) +} +\end{lstlisting} +This means that the name \code{Pair} can be used in place of \code{Tuple2} for tuple +formation as well as for deconstruction of tuples in patterns. +Hence, the following is possible: +\begin{lstlisting} +val x = (1, 2) +val y = x match { + case Pair(i, s) => Pair(s + i, i * i) +} +\end{lstlisting} + +\subsection{Pattern Sequences}\label{sec:pattern-seqs} + +\syntax\begin{lstlisting} + SimplePattern ::= StableId `(' [Patterns `,'] [varid `@'] `_' `*' `)' +\end{lstlisting} + +A pattern sequence $p_1 \commadots p_n$ appears in two +contexts. First, in a constructor pattern +$c(q_1 \commadots q_m, p_1 \commadots p_n$), where $c$ is a case +class which has $m+1$ primary constructor parameters, +ending in a repeated parameter (\sref{sec:repeated-params}) of type +$S*$. Second, in an extractor pattern +$x(p_1 \commadots p_n)$ if the extractor object $x$ has an +\code{unapplySeq} method with a result type conforming to +\lstinline@Seq[$S$]@, but does not have an \code{unapply} method that +matches $p_1 \commadots p_n$. +The expected type for the pattern sequence is in each case the type $S$. + +The last pattern in a pattern sequence may be a {\em sequence +wildcard} \code{_*}. Each element pattern $p_i$ is type-checked with +$S$ as expected type, unless it is a sequence wildcard. If a final +sequence wildcard is present, the pattern matches all values $v$ that +are sequences which start with elements matching patterns +$p_1 \commadots p_{n-1}$. If no final sequence wildcard is given, the +pattern matches all values $v$ that are sequences of +length $n$ which consist of elements matching patterns $p_1 \commadots +p_n$. + +\subsection{Infix Operation Patterns} + +\syntax\begin{lstlisting} + Pattern3 ::= SimplePattern {id [nl] SimplePattern} +\end{lstlisting} + +An infix operation pattern $p;\op;q$ is a shorthand for the +constructor or extractor pattern $\op(p, q)$. The precedence and +associativity of operators in patterns is the same as in expressions +(\sref{sec:infix-operations}). + +An infix operation pattern $p;\op;(q_1 \commadots q_n)$ is a +shorthand for the constructor or extractor pattern $\op(p, q_1 +\commadots q_n)$. + +\subsection{Pattern Alternatives} + +\syntax\begin{lstlisting} + Pattern ::= Pattern1 { `|' Pattern1 } +\end{lstlisting} + +A pattern alternative ~\lstinline@$p_1$ | $\ldots$ | $p_n$@~ +consists of a number of alternative patterns $p_i$. All alternative +patterns are type checked with the expected type of the pattern. They +may no bind variables other than wildcards. The alternative pattern +matches a value $v$ if at least one its alternatives matches $v$. + +\subsection{XML Patterns} + +XML patterns are treated in \sref{sec:xml-pats}. + +\subsection{Regular Expression Patterns}\label{sec:reg-pats} + +Regular expression patterns have been discontinued in Scala from version 2.0. + +Later version of Scala provide a much simplified version of regular +expression patterns that cover most scenarios of non-text sequence +processing. A {\em sequence pattern} is a pattern that stands in a +position where either (1) a pattern of a type \lstinline+T+ which is +conforming to +\lstinline+Seq[A]+ for some \lstinline+A+ is expected, or (2) a case +class constructor that has an iterated formal parameter +\lstinline+A*+. A wildcard star pattern \lstinline+_*+ in the +rightmost position stands for arbitrary long sequences. It can be +bound to variables using \lstinline+@+, as usual, in which case the variable will have the +type \lstinline+Seq[A]+. + +\comment{ +\syntax\begin{lstlisting} + Pattern ::= Pattern1 { `|' Pattern1 } + Pattern1 ::= varid `:' Type + | `_' `:' Type + | Pattern2 + Pattern2 ::= [varid `@'] Pattern3 + Pattern3 ::= SimplePattern [ `*' | `?' | `+' ] + | SimplePattern { id' SimplePattern } + SimplePattern ::= `_' + | varid + | Literal + | `null' + | StableId [ `(' [Patterns] `)' ] + | `(' [Patterns] `)' + Patterns ::= Pattern {`,' Pattern} + id' ::= id $\textit{ but not }$ '*' | '?' | '+' | `@' | `|' +\end{lstlisting} + +We distinguish between tree patterns and hedge patterns (hedges +are ordered sequences of trees). A {\em tree pattern} describes +a set of matching trees (like above). A {\em hedge pattern} describes +a set of matching hedges. Both kinds of patterns may contain {\em +variable bindings} which serve to extract constituents of a tree or hedge. + +The type of a patterns and the expected types of variables +within patterns are determined by the context and the structure of the +patterns. The last case ensures that a variable bound +to a hedge pattern will have a sequence type. + +The following patterns are added: + +A {\em hedge pattern} $p_1 \commadots p_n$ where $n \geq 0$ is a +sequence of patterns separated by commas and matching the hedge described +by the components. Hedge patterns may appear as arguments to constructor +applications, or nested within another hedge pattern if grouped with +parentheses. Note that empty hedge patterns are allowed. The type of tree +patterns that appear in a hedge pattern is the expected type as +determined from the enclosing constructor. +A {\em fixed-length argument pattern} is a special hedge pattern where +where all $p_i$ are tree patterns. + +A {\em choice pattern} $p_1 | \ldots | p_n$ is a choice among several +alternatives, which may not contain variable-binding patterns. It +matches every tree and every hedge matched by at least one of its +alternatives. Note that the empty sequence may appear as an alternative. +An {\em option pattern} $p?$ is an abbreviation for $(p| )$. A choice is +a tree pattern if all its branches are tree patterns. In this case, all +branches must conform to the expected type and the type +of the choice is the least upper bound of the branches. Otherwise, +its type is determined by the enclosing hedge pattern it is part of. + +An {\em iterated pattern} $p*$ matches zero, one or more occurrences +of items matched by $p$, where $p$ may be either a tree pattern or a hedge pattern. $p$ may not +contain a variable-binding. A {\em non-empty iterated pattern} $p+$ is an +abbreviation for $(p,p*)$. + +The treatment of the following patterns changes with to the +previous section: + +A {\em constructor pattern} $c(p)$ consists of a simple type $c$ +followed by a pattern $p$. If $c$ designates a monomorphic case +class, then it must conform to the expected type of the pattern, the +pattern must be a fixed length argument pattern $p_1 \commadots p_n$ +whose length corresponds to the number of arguments of $c$'s primary +constructor. The expected types of the component patterns are then +taken from the formal parameter types of (said) constructor. If $c$ +designates a polymorphic case class, then there must be a unique type +application instance of it such that the instantiation of $c$ conforms +to the expected type of the pattern. The instantiated formal parameter +types of $c$'s primary constructor are then taken as the expected +types of the component patterns $p_1\commadots p_n$. In both cases, +the pattern matches all objects created from constructor invocations +$c(v_1 \commadots v_n)$ where each component pattern $p_i$ matches the +corresponding value $v_i$. If $c$ does not designate a case class, it +must be a subclass of \lstinline@Seq[$T\,$]@. In that case $p$ may be an +arbitrary sequence pattern. Value patterns in $p$ are expected to conform to +type $T$, and the pattern matches all objects whose \lstinline@elements()@ +method returns a sequence that matches $p$. + +The pattern $(p)$ is regarded as equivalent to the pattern $p$, if $p$ +is a nonempty sequence pattern. The empty tuple $()$ is a shorthand +for the constructor pattern \code{Unit}. + +A {\em variable-binding} $x @ p$ is a simple identifier $x$ +which starts with a lower case letter, together with a pattern $p$. It +matches every item (tree or hedge) matched by $p$, and in addition binds +it to the variable name. If $p$ is a tree pattern of type $T$, the type +of $x$ is also $T$. +If $p$ is a hedge pattern enclosed by constructor $c <: $\lstinline@Seq[$T\,$]@, +then the type of $x$ is \lstinline@List[$T\,$]@ +where $T$ is the expected type as dictated by the constructor. + +%A pattern consisting of only a variable $x$ is treated as the bound +%value pattern $x @ \_$. A typed pattern $x:T$ is treated as $x @ (_:T)$. +% +Regular expressions that contain variable bindings may be ambiguous, +i.e.\ there might be several ways to match a sequence against the +pattern. In these cases, the \emph{right-longest policy} applies: +patterns that appear more to the right than others in a sequence take +precedence in case of overlaps. + +\example Some examples of patterns are: +\begin{enumerate} +\item +The pattern ~\lstinline@ex: IOException@~ matches all instances of class +\code{IOException}, binding variable \code{ex} to the instance. +\item +The pattern ~\lstinline@Pair(x, _)@~ matches pairs of values, binding \code{x} to +the first component of the pair. The second component is matched +with a wildcard pattern. +\item +The pattern \ \code{List( x, y, xs @ _ * )} matches lists of length $\geq 2$, +binding \code{x} to the list's first element, \code{y} to the list's +second element, and \code{xs} to the remainder, which may be empty. +\item +The pattern \ \code{List( 1, x@(( 'a' | 'b' )+),y,_ )} matches a list that +contains 1 as its first element, continues with a non-empty sequence of +\code{'a'}s and \code{'b'}s, followed by two more elements. The sequence of 'a's and 'b's +is bound to \code{x}, and the next to last element is bound to \code{y}. +\item +The pattern \code{List( x@( 'a'* ), 'a'+ )} matches a non-empty list of +\code{'a'}s. Because of the shortest match policy, \code{x} will always be bound to +the empty sequence. +\item +The pattern \code{List( x@( 'a'+ ), 'a'* )} also matches a non-empty list of +\code{'a'}s. Here, \code{x} will always be bound to +the sequence containing one \code{'a'}. +\end{enumerate} + +} + +\subsection{Irrefutable Patterns} + +A pattern $p$ is {\em irrefutable} for a type $T$, if one of the following applies: +\begin{enumerate} +\item $p$ is a variable pattern, +\item $p$ is a typed pattern $x: T'$, and $T <: T'$, +\item $p$ is a constructor pattern $c(p_1 \commadots p_n)$, the type $T$ + is an instance of class $c$, the primary constructor + (\sref{sec:class-defs}) of type $T$ has + argument types $T_1 \commadots T_n$, and each $p_i$ is irrefutable for $T_i$. +\end{enumerate} + +%%% new patterns + +\section{Type Patterns}\label{sec:type-patterns} + +\syntax\begin{lstlisting} + TypePat ::= Type +\end{lstlisting} +Type patterns consist of types, type variables, and wildcards. +A type pattern $T$ is of one of the following forms: +\begin{itemize} +\item A reference to a class $C$, $p.C$, or \lstinline@$T$#$C$@. This +type pattern matches any non-null instance of the given class. +Note that the prefix of the class, if it is given, is relevant for determining +class instances. For instance, the pattern $p.C$ matches only +instances of classes $C$ which were created with the path $p$ as +prefix. + +The bottom types \code{scala.Nothing} and \code{scala.Null} cannot +be used as type patterns, because they would match nothing in any case. +\item +A singleton type \lstinline@$p$.type@. This type pattern matches only the value +denoted by the path $p$ (that is, a pattern match involved a +comparison of the matched value with $p$ using method \code{eq} in class +\code{AnyRef}). +\item +A compound type pattern \lstinline@$T_1$ with $\ldots$ with $T_n$@ where each $T_i$ is a +type pattern. This type pattern matches all values that are matched by each of +the type patterns $T_i$. +\item +A parameterized type pattern $T[a_1 \commadots a_n]$, where the $a_i$ +are type variable patterns or wildcards $\_$. +This type pattern matches all values which match $T$ for +some arbitrary instantiation of the type variables and wildcards. The +bounds or alias type of these type variable are determined as +described in (\sref{sec:type-param-inf-pat}). +\item +A parameterized type pattern \lstinline@scala.Array$[T_1]$@, where +$T_1$ is a type pattern. This type pattern matches any non-null instance +of type \lstinline@scala.Array$[U_1]$@, where $U_1$ is a type matched by $T_1$. +\end{itemize} +Types which are not of one of the forms described above are also +accepted as type patterns. However, such type patterns will be translated to their +erasure (\sref{sec:erasure}). The Scala +compiler will issue an ``unchecked'' warning for these patterns to +flag the possible loss of type-safety. + +A {\em type variable pattern} is a simple identifier which starts with +a lower case letter. However, the predefined primitive type aliases +\lstinline@unit@, \lstinline@boolean@, \lstinline@byte@, +\lstinline@short@, \lstinline@char@, \lstinline@int@, +\lstinline@long@, \lstinline@float@, and \lstinline@double@ are not +classified as type variable patterns. + +\section{Type Parameter Inference in Patterns}\label{sec:type-param-inf-pat} + +Type parameter inference is the process of finding bounds for the +bound type variables in a typed pattern or constructor +pattern. Inference takes into account the expected type of the +pattern. + +\paragraph{Type parameter inference for typed patterns.} +Assume a typed pattern $p: T'$. Let $T$ result from $T'$ where all wildcards in +$T'$ are renamed to fresh variable names. Let $a_1 \commadots a_n$ be +the type variables in $T$. These type variables are considered bound +in the pattern. Let the expected type of the pattern be $\proto$. + +Type parameter inference constructs first a set of subtype constraints over +the type variables $a_i$. The initial constraints set $\CC_0$ reflects +just the bounds of these type variables. That is, assuming $T$ has +bound type variables $a_1 \commadots a_n$ which correspond to class +type parameters $a'_1 \commadots a'_n$ with lower bounds $L_1 +\commadots L_n$ and upper bounds $U_1 \commadots U_n$, $\CC_0$ +contains the constraints \bda{rcll} a_i &<:& \sigma U_i & \gap (i = 1 +\commadots n)\\ \sigma L_i &<:& a_i & \gap (i = 1 \commadots n) \eda +where $\sigma$ is the substitution $[a'_1 := a_1 \commadots a'_n := +a_n]$. + +The set $\CC_0$ is then augmented by further subtype constraints. There are two +cases. + +\paragraph{Case 1:} +If there exists a substitution $\sigma$ over the type variables $a_i +\commadots a_n$ such that $\sigma T$ conforms to $\proto$, one determines +the weakest subtype constraints $\CC_1$ over the type variables $a_1 +\commadots a_n$ such that $\CC_0 \wedge \CC_1$ implies that $T$ +conforms to $\proto$. + +\paragraph{Case 2:} +Otherwise, if $T$ can not be made to conform to $\proto$ by +instantiating its type variables, one determines all type variables in +$\proto$ which are defined as type parameters of a method enclosing +the pattern. Let the set of such type parameters be $b_1 \commadots +b_m$. Let $\CC'_0$ be the subtype constraints reflecting the bounds of the +type variables $b_i$. If $T$ denotes an instance type of a final +class, let $\CC_2$ be the weakest set of subtype constraints over the type +variables $a_1 \commadots a_n$ and $b_1 \commadots b_m$ such that +$\CC_0 \wedge \CC'_0 \wedge \CC_2$ implies that $T$ conforms to +$\proto$. If $T$ does not denote an instance type of a final class, +let $\CC_2$ be the weakest set of subtype constraints over the type variables +$a_1 \commadots a_n$ and $b_1 \commadots b_m$ such that $\CC_0 \wedge +\CC'_0 \wedge \CC_2$ implies that it is possible to construct a type +$T'$ which conforms to both $T$ and $\proto$. It is a static error if +there is no satisfiable set of constraints $\CC_2$ with this property. + +The final step consists in choosing type bounds for the type +variables which imply the established constraint system. The process +is different for the two cases above. + +\paragraph{Case 1:} +We take $a_i >: L_i <: U_i$ where each +$L_i$ is minimal and each $U_i$ is maximal wrt $<:$ such that +$a_i >: L_i <: U_i$ for $i = 1 \commadots n$ implies $\CC_0 \wedge \CC_1$. + +\paragraph{Case 2:} +We take $a_i >: L_i <: U_i$ and $b_i >: L'_i <: U'_i$ where each $L_i$ +and $L'_j$ is minimal and each $U_i$ and $U'_j$ is maximal such that +$a_i >: L_i <: U_i$ for $i = 1 \commadots n$ and +$b_j >: L'_j <: U'_j$ for $j = 1 \commadots m$ +implies $\CC_0 \wedge \CC'_0 \wedge \CC_2$. + +In both cases, local type inference is permitted to limit the +complexity of inferred bounds. Minimality and maximality of types have +to be understood relative to the set of types of acceptable +complexity. + +\paragraph{Type parameter inference for constructor patterns.} +Assume a constructor pattern $C(p_1 \commadots p_n)$ where class $C$ +has type type parameters $a_1 \commadots a_n$. These type parameters +are inferred in the same way as for the typed pattern +~\lstinline@(_: $C[a_1 \commadots a_n]$)@. + +\example +Consider the program fragment: +\begin{lstlisting} +val x: Any +x match { + case y: List[a] => ... +} +\end{lstlisting} +Here, the type pattern \lstinline@List[a]@ is matched against the +expected type \lstinline@Any@. The pattern binds the type variable +\lstinline@a@. Since \lstinline@List[a]@ conforms to \lstinline@Any@ +for every type argument, there are no constraints on \lstinline@a@. +Hence, \lstinline@a@ is introduced as an abstract type with no +bounds. The scope of \lstinline@a@ is right-hand side of its case clause. + +On the other hand, if \lstinline@x@ is declared as +\begin{lstlisting} +val x: List[List[String]], +\end{lstlisting} +this generates the constraint +~\lstinline@List[a] <: List[List[String]]@, which simplifies to +~\lstinline@a <: List[String]@, because \lstinline@List@ is covariant. Hence, +\lstinline@a@ is introduced with upper bound +\lstinline@List[String]@. + +\example +Consider the program fragment: +\begin{lstlisting} +val x: Any +x match { + case y: List[String] => ... +} +\end{lstlisting} +Scala does not maintain information about type arguments at run-time, +so there is no way to check that \lstinline@x@ is a list of strings. +Instead, the Scala compiler will erase (\sref{sec:erasure}) the +pattern to \lstinline@List[_]@; that is, it will only test whether the +top-level runtime-class of the value \lstinline@x@ conforms to +\lstinline@List@, and the pattern match will succeed if it does. This +might lead to a class cast exception later on, in the case where the +list \lstinline@x@ contains elements other than strings. The Scala +compiler will flag this potential loss of type-safety with an +``unchecked'' warning message. + +\example +Consider the program fragment +\begin{lstlisting} +class Term[A] +class Number(val n: Int) extends Term[Int] +def f[B](t: Term[B]): B = t match { + case y: Number => y.n +} +\end{lstlisting} +The expected type of the pattern ~\lstinline@y: Number@~ is +~\lstinline@Term[B]@. The type \code{Number} does not conform to +~\lstinline@Term[B]@; hence Case 2 of the rules above +applies. This means that \lstinline@b@ is treated as another type +variable for which subtype constraints are inferred. In our case the +applicable constraint is ~\lstinline@Number <: Term[B]@, which +entails \lstinline@B = Int@. Hence, \lstinline@B@ is treated in +the case clause as an abstract type with lower and upper bound +\lstinline@Int@. Therefore, the right hand side of the case clause, +\lstinline@y.n@, of type \lstinline@Int@, is found to conform to the +function's declared result type, \lstinline@Number@. + +\section{Pattern Matching Expressions} +\label{sec:pattern-match} + +\syntax\begin{lstlisting} + Expr ::= PostfixExpr `match' `{' CaseClauses `}' + CaseClauses ::= CaseClause {CaseClause} + CaseClause ::= `case' Pattern [Guard] `=>' Block +\end{lstlisting} + +A pattern matching expression +\begin{lstlisting} +e match { case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ } +\end{lstlisting} +consists of a selector expression $e$ and a number $n > 0$ of +cases. Each case consists of a (possibly guarded) pattern $p_i$ and a +block $b_i$. Each $p_i$ might be complemented by a guard +~\lstinline@if $e$@~ where $e$ is a boolean expression. +The scope of the pattern +variables in $p_i$ comprises the pattern's guard and the corresponding block $b_i$. + +Let $T$ be the type of the selector expression $e$ and let $a_1 +\commadots a_m$ be the type parameters of all methods enclosing +the pattern matching expression. For every $a_i$, let $L_i$ be its +lower bound and $U_i$ be its higher bound. Every pattern $p \in +\{p_1, \commadots p_n\}$ can be typed in two ways. First, it is attempted +to type $p$ with $T$ as its expected type. If this fails, $p$ is +instead typed with a modified expected type $T'$ which results from +$T$ by replacing every occurrence of a type parameter $a_i$ by +\mbox{\sl undefined}. If this second step fails also, a compile-time +error results. If the second step succeeds, let $T_p$ be the type of +pattern $p$ seen as an expression. One then determines minimal bounds +$L'_1 \commadots L'_m$ and maximal bounds $U'_1 \commadots U'_m$ such +that for all $i$, $L_i <: L'_i$ and $U'_i <: U_i$ and the following +constraint system is satisfied: +\[ + L_1 <: a_1 <: U_1\;\wedge\;\ldots\;\wedge\;L_m <: a_m <: U_m + \ \Rightarrow\ T_p <: T +\] +If no such bounds can be found, a compile time error results. If such +bounds are found, the pattern matching clause starting with $p$ is +then typed under the assumption that each $a_i$ has lower bound $L'_i$ +instead of $L_i$ and has upper bound $U'_i$ instead of $U_i$. + +The expected type of every block $b_i$ is the expected type of the +whole pattern matching expression. The type of the pattern matching +expression is then the weak least upper bound +(\sref{sec:weakconformance}) +of the types of all blocks +$b_i$. + +When applying a pattern matching expression to a selector value, +patterns are tried in sequence until one is found which matches the +selector value (\sref{sec:patterns}). Say this case is $\CASE;p_i +\Arrow b_i$. The result of the whole expression is then the result of +evaluating $b_i$, where all pattern variables of $p_i$ are bound to +the corresponding parts of the selector value. If no matching pattern +is found, a \code{scala.MatchError} exception is thrown. + +The pattern in a case may also be followed by a guard suffix \ +\code{if e}\ with a boolean expression $e$. The guard expression is +evaluated if the preceding pattern in the case matches. If the guard +expression evaluates to \code{true}, the pattern match succeeds as +normal. If the guard expression evaluates to \code{false}, the pattern +in the case is considered not to match and the search for a matching +pattern continues. + +In the interest of efficiency the evaluation of a pattern matching +expression may try patterns in some other order than textual +sequence. This might affect evaluation through +side effects in guards. However, it is guaranteed that a guard +expression is evaluated only if the pattern it guards matches. + +If the selector of a pattern match is an instance of a +\lstinline@sealed@ class (\sref{sec:modifiers}), +the compilation of pattern matching can emit warnings which diagnose +that a given set of patterns is not exhaustive, i.e.\ that there is a +possibility of a \code{MatchError} being raised at run-time. + +\example\label{ex:eval} + Consider the following definitions of arithmetic terms: + +\begin{lstlisting} +abstract class Term[T] +case class Lit(x: Int) extends Term[Int] +case class Succ(t: Term[Int]) extends Term[Int] +case class IsZero(t: Term[Int]) extends Term[Boolean] +case class If[T](c: Term[Boolean], + t1: Term[T], + t2: Term[T]) extends Term[T] +\end{lstlisting} +There are terms to represent numeric literals, incrementation, a zero +test, and a conditional. Every term carries as a type parameter the +type of the expression it representes (either \code{Int} or \code{Boolean}). + +A type-safe evaluator for such terms can be written as follows. +\begin{lstlisting} +def eval[T](t: Term[T]): T = t match { + case Lit(n) => n + case Succ(u) => eval(u) + 1 + case IsZero(u) => eval(u) == 0 + case If(c, u1, u2) => eval(if (eval(c)) u1 else u2) +} +\end{lstlisting} +Note that the evaluator makes crucial use of the fact that type +parameters of enclosing methods can acquire new bounds through pattern +matching. + +For instance, the type of the pattern in the second case, +~\lstinline@Succ(u)@, is \code{Int}. It conforms to the selector type +\code{T} only if we assume an upper and lower bound of \code{Int} for \code{T}. +Under the assumption ~\lstinline@Int <: T <: Int@~ we can also +verify that the type right hand side of the second case, \code{Int} +conforms to its expected type, \code{T}. + +\section{Pattern Matching Anonymous Functions} +\label{sec:pattern-closures} + +\syntax\begin{lstlisting} + BlockExpr ::= `{' CaseClauses `}' +\end{lstlisting} + +An anonymous function can be defined by a sequence of cases +\begin{lstlisting} +{ case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ } +\end{lstlisting} +which appear as an expression without a prior \code{match}. The +expected type of such an expression must in part be defined. It must +be either ~\lstinline@scala.Function$k$[$S_1 \commadots S_k$, $R$]@~ for some $k > 0$, +or ~\lstinline@scala.PartialFunction[$S_1$, $R$]@, where the +argument type(s) $S_1 \commadots S_k$ must be fully determined, but the result type +$R$ may be undetermined. + +If the expected type is ~\lstinline@scala.Function$k$[$S_1 \commadots S_k$, $R$]@~, +the expression is taken to be equivalent to the anonymous function: +\begin{lstlisting} +($x_1: S_1 \commadots x_k: S_k$) => ($x_1 \commadots x_k$) match { + case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ +} +\end{lstlisting} +Here, each $x_i$ is a fresh name. +As was shown in (\sref{sec:closures}), this anonymous function is in turn +equivalent to the following instance creation expression, where + $T$ is the weak least upper bound of the types of all $b_i$. +\begin{lstlisting} +new scala.Function$k$[$S_1 \commadots S_k$, $T$] { + def apply($x_1: S_1 \commadots x_k: S_k$): $T$ = ($x_1 \commadots x_k$) match { + case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ + } +} +\end{lstlisting} +If the expected type is ~\lstinline@scala.PartialFunction[$S$, $R$]@, +the expression is taken to be equivalent to the following instance creation expression: +\begin{lstlisting} +new scala.PartialFunction[$S$, $T$] { + def apply($x$: $S$): $T$ = x match { + case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ + } + def isDefinedAt($x$: $S$): Boolean = { + case $p_1$ => true $\ldots$ case $p_n$ => true + case _ => false + } +} +\end{lstlisting} +Here, $x$ is a fresh name and $T$ is the weak least upper bound of the +types of all $b_i$. The final default case in the \code{isDefinedAt} +method is omitted if one of the patterns $p_1 \commadots p_n$ is +already a variable or wildcard pattern. + +\example Here is a method which uses a fold-left operation +\code{/:} to compute the scalar product of +two vectors: +\begin{lstlisting} +def scalarProduct(xs: Array[Double], ys: Array[Double]) = + (0.0 /: (xs zip ys)) { + case (a, (b, c)) => a + b * c + } +\end{lstlisting} +The case clauses in this code are equivalent to the following +anonymous funciton: +\begin{lstlisting} + (x, y) => (x, y) match { + case (a, (b, c)) => a + b * c + } +\end{lstlisting} + diff --git a/11-top-level-definitions.md b/11-top-level-definitions.md new file mode 100644 index 000000000000..6d5d17246c88 --- /dev/null +++ b/11-top-level-definitions.md @@ -0,0 +1,177 @@ +Top-Level Definitions +===================== + +\section{Compilation Units} + +\syntax\begin{lstlisting} + CompilationUnit ::= {`package' QualId semi} TopStatSeq + TopStatSeq ::= TopStat {semi TopStat} + TopStat ::= {Annotation} {Modifier} TmplDef + | Import + | Packaging + | PackageObject + | + QualId ::= id {`.' id} +\end{lstlisting} + +A compilation unit consists of a sequence of packagings, import +clauses, and class and object definitions, which may be preceded by a +package clause. + +A compilation unit +\begin{lstlisting} +package $p_1$; +$\ldots$ +package $p_n$; +$\stats$ +\end{lstlisting} +starting with one or more package +clauses is equivalent to a compilation unit consisting of the +packaging +\begin{lstlisting} +package $p_1$ { $\ldots$ + package $p_n$ { + $\stats$ + } $\ldots$ +} +\end{lstlisting} + +Implicitly imported into every compilation unit are, in that order : +the package \code{java.lang}, the package \code{scala}, and the object +\code{scala.Predef} (\sref{cls:predef}). Members of a later import in +that order hide members of an earlier import. + +\section{Packagings}\label{sec:packagings} + +\syntax\begin{lstlisting} + Packaging ::= `package' QualId [nl] `{' TopStatSeq `}' +\end{lstlisting} + +A package is a special object which defines a set of member classes, +objects and packages. Unlike other objects, packages are not introduced +by a definition. Instead, the set of members of a package is determined by +packagings. + +A packaging ~\lstinline@package $p$ { $\ds$ }@~ injects all +definitions in $\ds$ as members into the package whose qualified name +is $p$. Members of a package are called {\em top-level} definitions. +If a definition in $\ds$ is labeled \code{private}, it is +visible only for other members in the package. + +Inside the packaging, all members of package $p$ are visible under their +simple names. However this rule does not extend to members of enclosing +packages of $p$ that are designated by a prefix of the path $p$. + +\example Given the packaging +\begin{lstlisting} +package org.net.prj { + ... +} +\end{lstlisting} +all members of package \lstinline@org.net.prj@ are visible under their +simple names, but members of packages \code{org} or \code{org.net} require +explicit qualification or imports. + +Selections $p$.$m$ from $p$ as well as imports from $p$ +work as for objects. However, unlike other objects, packages may not +be used as values. It is illegal to have a package with the same fully +qualified name as a module or a class. + +Top-level definitions outside a packaging are assumed to be injected +into a special empty package. That package cannot be named and +therefore cannot be imported. However, members of the empty package +are visible to each other without qualification. + +\section{Package Objects} +\label{sec:pkg-obj} + +\syntax\begin{lstlisting} + PackageObject ::= `package' `object' ObjectDef +\end{lstlisting} + +A package object ~\lstinline@package object $p$ extends $t$@~ adds the +members of template $t$ to the package $p$. There can be only one +package object per package. The standard naming convention is to place +the definition above in a file named \lstinline@package.scala@ that's +located in the directory corresponding to package $p$. + +The package object should not define a member with the same name as +one of the top-level objects or classes defined in package $p$. If +there is a name conflict, the behavior of the program is currently +undefined. It is expected that this restriction will be lifted in a +future version of Scala. + +\section{Package References} + +\syntax\begin{lstlisting} + QualId ::= id {`.' id} +\end{lstlisting} +A reference to a package takes the form of a qualified identifier. +Like all other references, package references are relative. That is, +a package reference starting in a name $p$ will be looked up in the +closest enclosing scope that defines a member named $p$. + +The special predefined name \lstinline@_root_@ refers to the +outermost root package which contains all top-level packages. + +\example\label{ex:package-ids} +Consider the following program: +\begin{lstlisting} +package b { + class B +} + +package a.b { + class A { + val x = new _root_.b.B + } +} +\end{lstlisting} +Here, the reference \code{_root_.b.B} refers to class \code{B} in the +toplevel package \code{b}. If the \code{_root_} prefix had been +omitted, the name \code{b} would instead resolve to the package +\code{a.b}, and, provided that package does not also +contain a class \code{B}, a compiler-time error would result. + +\section{Programs} + +A {\em program} is a top-level object that has a member method +\code{main} of type ~\lstinline@(Array[String])Unit@. Programs can be +executed from a command shell. The program's command arguments are are +passed to the \code{main} method as a parameter of type +\code{Array[String]}. + +The \code{main} method of a program can be directly defined in the +object, or it can be inherited. The scala library defines a class +\code{scala.Application} that defines an empty inherited \code{main} method. +An objects $m$ inheriting from this class is thus a program, +which executes the initializaton code of the object $m$. + +\example The following example will create a hello world program by defining +a method \code{main} in module \code{test.HelloWorld}. +\begin{lstlisting} +package test +object HelloWord { + def main(args: Array[String]) { println("hello world") } +} +\end{lstlisting} + +This program can be started by the command +\begin{lstlisting} +scala test.HelloWorld +\end{lstlisting} +In a Java environment, the command +\begin{lstlisting} +java test.HelloWorld +\end{lstlisting} +would work as well. + +\code{HelloWorld} can also be defined without a \code{main} method +by inheriting from \code{Application} instead: +\begin{lstlisting} +package test +object HelloWord extends Application { + println("hello world") +} +\end{lstlisting} + diff --git a/12-xml-expressions-and-patterns.md b/12-xml-expressions-and-patterns.md new file mode 100644 index 000000000000..2f6756b05fab --- /dev/null +++ b/12-xml-expressions-and-patterns.md @@ -0,0 +1,144 @@ +XML Expressions and Patterns +============================ + +{\bf By Burak Emir}\bigskip\bigskip + + +This chapter describes the syntactic structure of XML expressions and patterns. +It follows as closely as possible the XML 1.0 specification \cite{w3c:xml}, +changes being mandated by the possibility of embedding Scala code fragments. + +\section{XML expressions} +XML expressions are expressions generated by the following production, where the +opening bracket `<' of the first element must be in a position to start the lexical +[XML mode](#xml-mode). + +\syntax\begin{lstlisting} +XmlExpr ::= XmlContent {Element} +\end{lstlisting} +Well-formedness constraints of the XML specification apply, which +means for instance that start tags and end tags must match, and +attributes may only be defined once, with the exception of constraints +related to entity resolution. + +The following productions describe Scala's extensible markup language, +designed as close as possible to the W3C extensible markup language +standard. Only the productions for attribute values and character data +are changed. Scala does not support declarations, CDATA +sections or processing instructions. Entity references are not +resolved at runtime. + +\syntax\begin{lstlisting} +Element ::= EmptyElemTag + | STag Content ETag + +EmptyElemTag ::= `<' Name {S Attribute} [S] `/>' + +STag ::= `<' Name {S Attribute} [S] `>' +ETag ::= `' +Content ::= [CharData] {Content1 [CharData]} +Content1 ::= XmlContent + | Reference + | ScalaExpr +XmlContent ::= Element + | CDSect + | PI + | Comment +\end{lstlisting} + +If an XML expression is a single element, its value is a runtime +representation of an XML node (an instance of a subclass of +\lstinline@scala.xml.Node@). If the XML expression consists of more +than one element, then its value is a runtime representation of a +sequence of XML nodes (an instance of a subclass of +\lstinline@scala.Seq[scala.xml.Node]@). + +If an XML expression is an entity reference, CDATA section, processing +instructions or a comments, it is represented by an instance of the +corresponding Scala runtime class. + +By default, beginning and trailing whitespace in element content is removed, +and consecutive occurrences of whitespace are replaced by a single space +character \U{0020}. This behavior can be changed to preserve all whitespace +with a compiler option. + +\syntax\begin{lstlisting} +Attribute ::= Name Eq AttValue + +AttValue ::= `"' {CharQ | CharRef} `"' + | `'' {CharA | CharRef} `'' + | ScalaExpr + +ScalaExpr ::= Block + +CharData ::= { CharNoRef } $\mbox{\rm\em without}$ {CharNoRef}`{'CharB {CharNoRef} + $\mbox{\rm\em and without}$ {CharNoRef}`]]>'{CharNoRef} +\end{lstlisting} +XML expressions may contain Scala expressions as attribute values or +within nodes. In the latter case, these are embedded using a single opening +brace `\{' and ended by a closing brace `\}'. To express a single opening braces +within XML text as generated by CharData, it must be doubled. Thus, `\{\{' +represents the XML text `\{' and does not introduce an embedded Scala +expression. + +\syntax\begin{lstlisting} +BaseChar, Char, Comment, CombiningChar, Ideographic, NameChar, S, Reference + ::= $\mbox{\rm\em ``as in W3C XML''}$ + +Char1 ::= Char $\mbox{\rm\em without}$ `<' | `&' +CharQ ::= Char1 $\mbox{\rm\em without}$ `"' +CharA ::= Char1 $\mbox{\rm\em without}$ `'' +CharB ::= Char1 $\mbox{\rm\em without}$ '{' + +Name ::= XNameStart {NameChar} + +XNameStart ::= `_' | BaseChar | Ideographic + $\mbox{\rm\em (as in W3C XML, but without }$ `:' + +\end{lstlisting} +\section{XML patterns}\label{sec:xml-pats} +XML patterns are patterns generated by the following production, where +the opening bracket `<' of the element patterns must be in a position +to start the lexical [XML mode](#xml-mode). + +\syntax\begin{lstlisting} +XmlPattern ::= ElementPattern +\end{lstlisting}%{ElementPattern} +Well-formedness constraints of the XML specification apply. + +An XML pattern has to be a single element pattern. It %expects the type of , and +matches exactly those runtime +representations of an XML tree +that have the same structure as described by the pattern. %If an XML pattern +%consists of more than one element, then it expects the type of sequences +%of runtime representations of XML trees, and matches every sequence whose +%elements match the sequence described by the pattern. +XML patterns may contain Scala patterns(\sref{sec:pattern-match}). + +Whitespace is treated the same way as in XML expressions. Patterns +that are entity references, CDATA sections, processing +instructions and comments match runtime representations which are the +the same. + +By default, beginning and trailing whitespace in element content is removed, +and consecutive occurrences of whitespace are replaced by a single space +character \U{0020}. This behavior can be changed to preserve all whitespace +with a compiler option. + +\syntax\begin{lstlisting} +ElemPattern ::= EmptyElemTagP + | STagP ContentP ETagP + +EmptyElemTagP ::= `<' Name [S] `/>' +STagP ::= `<' Name [S] `>' +ETagP ::= `' +ContentP ::= [CharData] {(ElemPattern|ScalaPatterns) [CharData]} +ContentP1 ::= ElemPattern + | Reference + | CDSect + | PI + | Comment + | ScalaPatterns +ScalaPatterns ::= `{' Patterns `}' +\end{lstlisting} + diff --git a/13-user-defined-annotations.md b/13-user-defined-annotations.md new file mode 100644 index 000000000000..ec83e9fa4fc6 --- /dev/null +++ b/13-user-defined-annotations.md @@ -0,0 +1,174 @@ +User-Defined Annotations +======================== + +\syntax\begin{lstlisting} + Annotation ::= `@' SimpleType {ArgumentExprs} + ConstrAnnotation ::= `@' SimpleType ArgumentExprs +\end{lstlisting} + +User-defined annotations associate meta-information with definitions. +A simple annotation has the form \lstinline^@$c$^ or +\lstinline^@$c(a_1 \commadots a_n)$^. +Here, $c$ is a constructor of a class $C$, which must conform +to the class \lstinline@scala.Annotation@. + +Annotations may apply to definitions or declarations, types, or +expressions. An annotation of a definition or declaration appears in +front of that definition. An annotation of a type appears after +that type. An annotation of an expression $e$ appears after the +expression $e$, separated by a colon. More than one annotation clause +may apply to an entity. The order in which these annotations are given +does not matter. + +Examples: +\begin{lstlisting} +@serializable class C { ... } // A class annotation. +@transient @volatile var m: Int // A variable annotation +String @local // A type annotation +(e: @unchecked) match { ... } // An expression annotation +\end{lstlisting} + +The meaning of annotation clauses is implementation-dependent. On the +Java platform, the following annotations have a standard meaning.\bigskip + +\lstinline^@transient^ +\begin{quote} +Marks a field to be non-persistent; this is +equivalent to the \lstinline^transient^ +modifier in Java. +\end{quote} + +\lstinline^@volatile^ +\begin{quote}Marks a field which can change its value +outside the control of the program; this +is equivalent to the \lstinline^volatile^ +modifier in Java. +\end{quote} + +\lstinline^@serializable^ +\begin{quote}Marks a class to be serializable; this is +equivalent to inheriting from the +\lstinline^java.io.Serializable^ interface +in Java. +\end{quote} + +\lstinline^@SerialVersionUID()^ +\begin{quote}Attaches a serial version identifier (a +\lstinline^long^ constant) to a class. +This is equivalent to a the following field +definition in Java: +\begin{lstlisting}[language=Java] + private final static SerialVersionUID = +\end{lstlisting} +\end{quote} + +\lstinline^@throws()^ +\begin{quote} +A Java compiler checks that a program contains handlers for checked exceptions +by analyzing which checked exceptions can result from execution of a method or +constructor. For each checked exception which is a possible result, the \code{throws} +clause for the method or constructor must mention the class of that exception +or one of the superclasses of the class of that exception. +\end{quote} + +\lstinline^@deprecated()^ +\begin{quote} Marks a definition as deprecated. Accesses to the + defined entity will then cause a deprecated warning mentioning the + message \code{} to be issued from the compiler. Deprecated + warnings are suppressed in code that belongs itself to a definition + that is labeled deprecated. +\end{quote} + +\lstinline^@scala.reflect.BeanProperty^ +\begin{quote} +When prefixed to a definition of some variable \code{X}, this +annotation causes getter and setter methods \code{getX}, \code{setX} +in the Java bean style to be added in the class containing the +variable. The first letter of the variable appears capitalized after +the \code{get} or \code{set}. When the annotation is added to the +definition of an immutable value definition \code{X}, only a getter is +generated. The construction of these methods is part of +code-generation; therefore, these methods become visible only once a +classfile for the containing class is generated. +\end{quote} + +\lstinline^@scala.reflect.BooleanBeanProperty^ +\begin{quote} +This annotation is equivalent to \code{scala.reflect.BeanProperty}, but +the generated getter method is named \code{isX} instead of \code{getX}. +\end{quote} + +\lstinline^@unchecked^ +\begin{quote} +When applied to the selector of a \lstinline@match@ expression, +this attribute suppresses any warnings about non-exhaustive pattern +matches which would otherwise be emitted. For instance, no warnings +would be produced for the method definition below. +\begin{lstlisting} +def f(x: Option[Int]) = (x: @unchecked) match { + case Some(y) => y +} +\end{lstlisting} +Without the \lstinline^@unchecked^ annotation, a Scala compiler could +infer that the pattern match is non-exhaustive, and could produce a +warning because \lstinline@Option@ is a \lstinline@sealed@ class. +\end{quote} + +\lstinline^@uncheckedStable^ +\begin{quote} +When applied a value declaration or definition, it allows the defined +value to appear in a path, even if its type is volatile (\sref{volatile-types}). +For instance, the following member definitions are legal: +\begin{lstlisting} +type A { type T } +type B +@uncheckedStable val x: A with B // volatile type +val y: x.T // OK since `x' is still a path +\end{lstlisting} +Without the \lstinline^@uncheckedStable^ annotation, the designator \code{x} +would not be a path since its type \code{A with B} is volatile. Hence, +the reference \code{x.T} would be malformed. + +When applied to value declarations or definitions that have non-volatile types, +the annotation has no effect. +\end{quote} + +\lstinline^@specialized^ +\begin{quote} +When applied to the definition of a type parameter, this annotation causes the compiler +to generate specialized definitions for primitive types. An optional list of primitive +types may be given, in which case specialization takes into account only those types. +For instance, the following code would generate specialized traits for \lstinline@Unit@, +\lstinline@Int@ and \lstinline@Double@ +\begin{lstlisting} +trait Function0[@specialized(Unit, Int, Double) T] { + def apply: T +} +\end{lstlisting} +Whenever the static type of an expression matches a specialized variant of a definition, +the compiler will instead use the specialized version. See \cite{spec-sid} for more details +of the implementation. +\end{quote} + + +Other annotations may be interpreted by platform- or +application-dependent tools. Class \code{scala.Annotation} has two +sub-traits which are used to indicate how these annotations are +retained. Instances of an annotation class inheriting from trait +\code{scala.ClassfileAnnotation} will be stored in the generated class +files. Instances of an annotation class inheriting from trait +\code{scala.StaticAnnotation} will be visible to the Scala type-checker +in every compilation unit where the annotated symbol is accessed. An +annotation class can inherit from both \code{scala.ClassfileAnnotation} +and \code{scala.StaticAnnotation}. If an annotation class inherits from +neither \code{scala.ClassfileAnnotation} nor +\code{scala.StaticAnnotation}, its instances are visible only locally +during the compilation run that analyzes them. + +Classes inheriting from \code{scala.ClassfileAnnotation} may be +subject to further restrictions in order to assure that they can be +mapped to the host environment. In particular, on both the Java and +the .NET platforms, such classes must be toplevel; i.e.\ they may not +be contained in another class or object. Additionally, on both +Java and .NET, all constructor arguments must be constant expressions. + diff --git a/14-the-scala-standard-library.md b/14-the-scala-standard-library.md new file mode 100644 index 000000000000..60eded661022 --- /dev/null +++ b/14-the-scala-standard-library.md @@ -0,0 +1,932 @@ +The Scala Standard Library +========================== + +The Scala standard library consists of the package \code{scala} with a +number of classes and modules. Some of these classes are described in +the following. + +\begin{figure*} +\centering +\includegraphics[scale=0.40]{classhierarchy} +\vspace*{-1.5mm} +\caption{Class hierarchy of Scala.} +\label{fig:class-hierarchy} +\end{figure*} + +\section{Root Classes} +\label{sec:cls-root} +\label{sec:cls-any} +\label{sec:cls-object} + +Figure~\ref{fig:class-hierarchy} illustrates Scala's class +hierarchy. +The root of this hierarchy is formed by class \code{Any}. +Every class in a Scala execution environment inherits directly or +indirectly from this class. Class \code{Any} has two direct +subclasses: \code{AnyRef} and \code{AnyVal}. + +The subclass \code{AnyRef} represents all values which are represented +as objects in the underlying host system. Every user-defined Scala +class inherits directly or indirectly from this class. Furthermore, +every user-defined Scala class also inherits the trait +\code{scala.ScalaObject}. Classes written in other languages still +inherit from \code{scala.AnyRef}, but not from +\code{scala.ScalaObject}. + +The class \code{AnyVal} has a fixed number of subclasses, which describe +values which are not implemented as objects in the underlying host +system. + +Classes \code{AnyRef} and \code{AnyVal} are required to provide only +the members declared in class \code{Any}, but implementations may add +host-specific methods to these classes (for instance, an +implementation may identify class \code{AnyRef} with its own root +class for objects). + +The signatures of these root classes are described by the following +definitions. + +\begin{lstlisting} +package scala +/** The universal root class */ +abstract class Any { + + /** Defined equality; abstract here */ + def equals(that: Any): Boolean + + /** Semantic equality between values */ + final def == (that: Any): Boolean = + if (null eq this) null eq that else this equals that + + /** Semantic inequality between values */ + final def != (that: Any): Boolean = !(this == that) + + /** Hash code; abstract here */ + def hashCode: Int = $\ldots$ + + /** Textual representation; abstract here */ + def toString: String = $\ldots$ + + /** Type test; needs to be inlined to work as given */ + def isInstanceOf[a]: Boolean + + /** Type cast; needs to be inlined to work as given */ */ + def asInstanceOf[A]: A = this match { + case x: A => x + case _ => if (this eq null) this + else throw new ClassCastException() + } +} + +/** The root class of all value types */ +final class AnyVal extends Any + +/** The root class of all reference types */ +class AnyRef extends Any { + def equals(that: Any): Boolean = this eq that + final def eq(that: AnyRef): Boolean = $\ldots$ // reference equality + final def ne(that: AnyRef): Boolean = !(this eq that) + + def hashCode: Int = $\ldots$ // hashCode computed from allocation address + def toString: String = $\ldots$ // toString computed from hashCode and class name + + def synchronized[T](body: => T): T // execute `body` in while locking `this`. +} + +/** A mixin class for every user-defined Scala class */ +trait ScalaObject extends AnyRef +\end{lstlisting} + +The type test \lstinline@$x$.isInstanceOf[$T$]@ is equivalent to a typed +pattern match +\begin{lstlisting} +$x$ match { + case _: $T'$ => true + case _ => false +} +\end{lstlisting} +where the type $T'$ is the same as $T$ except if $T$ is +of the form $D$ or $D[\tps]$ where $D$ is a type member of some outer +class $C$. In this case $T'$ is \lstinline@$C$#$D$@ (or +\lstinline@$C$#$D[tps]$@, respectively), whereas $T$ itself would +expand to \lstinline@$C$.this.$D[tps]$@. In other words, an +\lstinline@isInstanceOf@ test does not check for the + + +The test ~\lstinline@$x$.asInstanceOf[$T$]@ is treated specially if $T$ is a +numeric value type (\sref{sec:cls-value}). In this case the cast will +be translated to an application of a conversion method ~\lstinline@x.to$T$@ +(\sref{cls:numeric-value}). For non-numeric values $x$ the operation will raise a +\code{ClassCastException}. + +\section{Value Classes} +\label{sec:cls-value} + +Value classes are classes whose instances are not represented as +objects by the underlying host system. All value classes inherit from +class \code{AnyVal}. Scala implementations need to provide the +value classes \code{Unit}, \code{Boolean}, \code{Double}, \code{Float}, +\code{Long}, \code{Int}, \code{Char}, \code{Short}, and \code{Byte} +(but are free to provide others as well). +The signatures of these classes are defined in the following. + +\subsection{Numeric Value Types} \label{cls:numeric-value} + +Classes \code{Double}, \code{Float}, +\code{Long}, \code{Int}, \code{Char}, \code{Short}, and \code{Byte} +are together called {\em numeric value types}. Classes \code{Byte}, +\code{Short}, or \code{Char} are called {\em subrange types}. +Subrange types, as well as \code{Int} and \code{Long} are called {\em +integer types}, whereas \code{Float} and \code{Double} are called {\em +floating point types}. + +Numeric value types are ranked in the following partial order: + +\begin{lstlisting} +Byte - Short + \ + Int - Long - Float - Double + / + Char +\end{lstlisting} +\code{Byte} and \code{Short} are the lowest-ranked types in this order, +whereas \code{Double} is the highest-ranked. Ranking does {\em not} +imply a conformance (\sref{sec:conformance}) relationship; for +instance \code{Int} is not a subtype of \code{Long}. However, object +\code{Predef} (\sref{cls:predef}) defines views (\sref{sec:views}) +from every numeric value type to all higher-ranked numeric value types. Therefore, +lower-ranked types are implicitly converted to higher-ranked types +when required by the context (\sref{sec:impl-conv}). + +Given two numeric value types $S$ and $T$, the {\em operation type} of +$S$ and $T$ is defined as follows: If both $S$ and $T$ are subrange +types then the operation type of $S$ and $T$ is \code{Int}. Otherwise +the operation type of $S$ and $T$ is the larger of the two types wrt +ranking. Given two numeric values $v$ and $w$ the operation type of +$v$ and $w$ is the operation type of their run-time types. + +Any numeric value type $T$ supports the following methods. +\begin{itemize} +\item +Comparison methods for equals (\code{==}), not-equals (\code{!=}), +less-than (\code{<}), greater-than (\code{>}), less-than-or-equals +(\code{<=}), greater-than-or-equals (\code{>=}), which each exist in 7 +overloaded alternatives. Each alternative takes a parameter of some +numeric value type. Its result type is type \code{Boolean}. The +operation is evaluated by converting the receiver and its argument to +their operation type and performing the given comparison operation of +that type. +\item +Arithmetic methods addition (\code{+}), subtraction (\code{-}), +multiplication (\code{*}), division (\code{/}), and remainder +(\lstinline@%@), which each exist in 7 overloaded alternatives. Each +alternative takes a parameter of some numeric value type $U$. Its +result type is the operation type of $T$ and $U$. The operation is +evaluated by converting the receiver and its argument to their +operation type and performing the given arithmetic operation of that +type. +\item +Parameterless arithmethic methods identity (\code{+}) and negation +(\code{-}), with result type $T$. The first of these returns the +receiver unchanged, whereas the second returns its negation. +\item +Conversion methods \code{toByte}, \code{toShort}, \code{toChar}, +\code{toInt}, \code{toLong}, \code{toFloat}, \code{toDouble} which +convert the receiver object to the target type, using the rules of +Java's numeric type cast operation. The conversion might truncate the +numeric value (as when going from \code{Long} to \code{Int} or from +\code{Int} to \code{Byte}) or it might lose precision (as when going +from \code{Double} to \code{Float} or when converting between +\code{Long} and \code{Float}). +\end{itemize} + +Integer numeric value types support in addition the following operations: +\begin{itemize} +\item +Bit manipulation methods bitwise-and (\code{&}), bitwise-or +{\code{|}}, and bitwise-exclusive-or (\code{^}), which each exist in 5 +overloaded alternatives. Each alternative takes a parameter of some +integer numeric value type. Its result type is the operation type of +$T$ and $U$. The operation is evaluated by converting the receiver and +its argument to their operation type and performing the given bitwise +operation of that type. +\item +A parameterless bit-negation method (\lstinline@~@). Its result type is +the reciver type $T$ or \code{Int}, whichever is larger. +The operation is evaluated by converting the receiver to the result +type and negating every bit in its value. +\item +Bit-shift methods left-shift (\code{<<}), arithmetic right-shift +(\code{>>}), and unsigned right-shift (\code{>>>}). Each of these +methods has two overloaded alternatives, which take a parameter $n$ +of type \code{Int}, respectively \code{Long}. The result type of the +operation is the receiver type $T$, or \code{Int}, whichever is larger. +The operation is evaluated by converting the receiver to the result +type and performing the specified shift by $n$ bits. +\end{itemize} + +Numeric value types also implement operations \code{equals}, +\code{hashCode}, and \code{toString} from class \code{Any}. + +The \code{equals} method tests whether the argument is a numeric value +type. If this is true, it will perform the \code{==} operation which +is appropriate for that type. That is, the \code{equals} method of a +numeric value type can be thought of being defined as follows: +\begin{lstlisting} +def equals(other: Any): Boolean = other match { + case that: Byte => this == that + case that: Short => this == that + case that: Char => this == that + case that: Int => this == that + case that: Long => this == that + case that: Float => this == that + case that: Double => this == that + case _ => false +} +\end{lstlisting} +The \code{hashCode} method returns an integer hashcode that maps equal +numeric values to equal results. It is guaranteed to be the identity for +for type \code{Int} and for all subrange types. + +The \code{toString} method displays its receiver as an integer or +floating point number. + +\example As an example, here is the signature of the numeric value type \code{Int}: + +\begin{lstlisting} +package scala +abstract sealed class Int extends AnyVal { + def == (that: Double): Boolean // double equality + def == (that: Float): Boolean // float equality + def == (that: Long): Boolean // long equality + def == (that: Int): Boolean // int equality + def == (that: Short): Boolean // int equality + def == (that: Byte): Boolean // int equality + def == (that: Char): Boolean // int equality + /* analogous for !=, <, >, <=, >= */ + + def + (that: Double): Double // double addition + def + (that: Float): Double // float addition + def + (that: Long): Long // long addition + def + (that: Int): Int // int addition + def + (that: Short): Int // int addition + def + (that: Byte): Int // int addition + def + (that: Char): Int // int addition + /* analogous for -, *, /, % */ + + def & (that: Long): Long // long bitwise and + def & (that: Int): Int // int bitwise and + def & (that: Short): Int // int bitwise and + def & (that: Byte): Int // int bitwise and + def & (that: Char): Int // int bitwise and + /* analogous for |, ^ */ + + def << (cnt: Int): Int // int left shift + def << (cnt: Long): Int // long left shift + /* analogous for >>, >>> */ + + def unary_+ : Int // int identity + def unary_- : Int // int negation + def unary_~ : Int // int bitwise negation + + def toByte: Byte // convert to Byte + def toShort: Short // convert to Short + def toChar: Char // convert to Char + def toInt: Int // convert to Int + def toLong: Long // convert to Long + def toFloat: Float // convert to Float + def toDouble: Double // convert to Double +} +\end{lstlisting} + +\subsection{Class \large{\code{Boolean}}} +\label{sec:cls-boolean} + +Class \code{Boolean} has only two values: \code{true} and +\code{false}. It implements operations as given in the following +class definition. +\begin{lstlisting} +package scala +abstract sealed class Boolean extends AnyVal { + def && (p: => Boolean): Boolean = // boolean and + if (this) p else false + def || (p: => Boolean): Boolean = // boolean or + if (this) true else p + def & (x: Boolean): Boolean = // boolean strict and + if (this) x else false + def | (x: Boolean): Boolean = // boolean strict or + if (this) true else x + def == (x: Boolean): Boolean = // boolean equality + if (this) x else x.unary_! + def != (x: Boolean): Boolean // boolean inequality + if (this) x.unary_! else x + def unary_!: Boolean // boolean negation + if (this) false else true +} +\end{lstlisting} +The class also implements operations \code{equals}, \code{hashCode}, +and \code{toString} from class \code{Any}. + +The \code{equals} method returns \code{true} if the argument is the +same boolean value as the receiver, \code{false} otherwise. The +\code{hashCode} method returns a fixed, implementation-specific hash-code when invoked on \code{true}, +and a different, fixed, implementation-specific hash-code when invoked on \code{false}. The \code{toString} method +returns the receiver converted to a string, i.e.\ either \code{"true"} +or \code{"false"}. + +\subsection{Class \large{\code{Unit}}} + +Class \code{Unit} has only one value: \code{()}. It implements only +the three methods \code{equals}, \code{hashCode}, and \code{toString} +from class \code{Any}. + +The \code{equals} method returns \code{true} if the argument is the +unit value \lstinline@()@, \code{false} otherwise. The +\code{hashCode} method returns a fixed, implementation-specific hash-code, +The \code{toString} method returns \code{"()"}. + +\section{Standard Reference Classes} +\label{cls:reference} + +This section presents some standard Scala reference classes which are +treated in a special way in Scala compiler -- either Scala provides +syntactic sugar for them, or the Scala compiler generates special code +for their operations. Other classes in the standard Scala library are +documented in the Scala library documentation by HTML pages. + +\subsection{Class \large{\code{String}}} + +Scala's \lstinline@String@ class is usually derived from the standard String +class of the underlying host system (and may be identified with +it). For Scala clients the class is taken to support in each case a +method +\begin{lstlisting} +def + (that: Any): String +\end{lstlisting} +which concatenates its left operand with the textual representation of its +right operand. + +\subsection{The \large{\code{Tuple}} classes} + +Scala defines tuple classes \lstinline@Tuple$n$@ for $n = 2 \commadots 9$. +These are defined as follows. + +\begin{lstlisting} +package scala +case class Tuple$n$[+a_1, ..., +a_n](_1: a_1, ..., _$n$: a_$n$) { + def toString = "(" ++ _1 ++ "," ++ $\ldots$ ++ "," ++ _$n$ ++ ")" +} +\end{lstlisting} + +The implicitly imported \code{Predef} object (\sref{cls:predef}) defines +the names \code{Pair} as an alias of \code{Tuple2} and \code{Triple} +as an alias for \code{Tuple3}. + +\subsection{The \large{\code{Function}} Classes} +\label{sec:cls-function} + +Scala defines function classes \lstinline@Function$n$@ for $n = 1 \commadots 9$. +These are defined as follows. + +\begin{lstlisting} +package scala +trait Function$n$[-a_1, ..., -a_$n$, +b] { + def apply(x_1: a_1, ..., x_$n$: a_$n$): b + def toString = "" +} +\end{lstlisting} + +\comment{ +There is also a module \code{Function}, defined as follows. +\begin{lstlisting} +package scala +object Function { + def compose[A](fs: List[A => A]): A => A = { + x => fs match { + case Nil => x + case f :: fs1 => compose(fs1)(f(x)) + } + } +} +\end{lstlisting} +} +A subclass of \lstinline@Function1@ represents partial functions, +which are undefined on some points in their domain. In addition to the +\code{apply} method of functions, partial functions also have a +\code{isDefined} method, which tells whether the function is defined +at the given argument: +\begin{lstlisting} +class PartialFunction[-A, +B] extends Function1[A, B] { + def isDefinedAt(x: A): Boolean +} +\end{lstlisting} + +The implicitly imported \code{Predef} object (\sref{cls:predef}) defines the name +\code{Function} as an alias of \code{Function1}. + +\subsection{Class \large{\code{Array}}}\label{cls:array} + +The class of generic arrays is given as follows. + +\begin{lstlisting} +final class Array[A](len: Int) extends Seq[A] { + def length: Int = len + def apply(i: Int): A = $\ldots$ + def update(i: Int, x: A): Unit = $\ldots$ + def elements: Iterator[A] = $\ldots$ + def subArray(from: Int, end: Int): Array[A] = $\ldots$ + def filter(p: A => Boolean): Array[A] = $\ldots$ + def map[B](f: A => B): Array[B] = $\ldots$ + def flatMap[B](f: A => Array[B]): Array[B] = $\ldots$ +} +\end{lstlisting} +If $T$ is not a type parameter or abstract type, the type Array[$T$] +is represented as the native array type \lstinline{[]$T$} in the +underlying host system. In that case \code{length} returns +the length of the array, \code{apply} means subscripting, and +\code{update} means element update. Because of the syntactic sugar for +\code{apply} and +%\code{update} operations (\sref{sec:impl-conv}, \sref{sec:assignments}), +\code{update} operations (\sref{sec:impl-conv}, +we have the following correspondences between Scala and Java/C\# code for +operations on an array \code{xs}: + +\begin{lstlisting} +$\mbox{\em Scala}$ $\mbox{\em Java/C\#}$ + xs.length xs.length + xs(i) xs[i] + xs(i) = e xs[i] = e +\end{lstlisting} + +Arrays also implement the sequence trait \code{scala.Seq} +by defining an \code{elements} method which returns +all elements of the array in an \code{Iterator}. + +Because of the tension between parametrized types in Scala and the ad-hoc +implementation of arrays in the host-languages, some subtle points +need to be taken into account when dealing with arrays. These are +explained in the following. + +First, unlike arrays in Java or C\#, arrays in Scala are {\em not} +co-variant; That is, $S <: T$ does not imply +~\lstinline@Array[$S$] $<:$ Array[$T$]@ in Scala. +However, it is possible to cast an array +of $S$ to an array of $T$ if such a cast is permitted in the host +environment. + +For instance \code{Array[String]} does not conform to +\code{Array[Object]}, even though \code{String} conforms to \code{Object}. +However, it is possible to cast an expression of type +~\lstinline@Array[String]@~ to ~\lstinline@Array[Object]@, and this +cast will succeed without raising a \code{ClassCastException}. Example: +\begin{lstlisting} +val xs = new Array[String](2) +// val ys: Array[Object] = xs // **** error: incompatible types +val ys: Array[Object] = xs.asInstanceOf[Array[Object]] // OK +\end{lstlisting} + +Second, for {\em polymorphic arrays}, that have a type parameter or +abstract type $T$ as their element type, a representation different +from +\lstinline@[]T@ might be used. However, it is guaranteed that +\code{isInstanceOf} and \code{asInstanceOf} still work as if the array +used the standard representation of monomorphic arrays: +\begin{lstlisting} +val ss = new Array[String](2) + +def f[T](xs: Array[T]): Array[String] = + if (xs.isInstanceOf[Array[String]]) xs.asInstanceOf[Array[String]) + else throw new Error("not an instance") + +f(ss) // returns ss +\end{lstlisting} +The representation chosen for polymorphic arrays also guarantees that +polymorphic array creations work as expected. An example is the +following implementation of method \lstinline@mkArray@, which creates +an array of an arbitrary type $T$, given a sequence of $T$'s which +defines its elements. +\begin{lstlisting} +def mkArray[T](elems: Seq[T]): Array[T] = { + val result = new Array[T](elems.length) + var i = 0 + for (elem <- elems) { + result(i) = elem + i += 1 + } +} +\end{lstlisting} +Note that under Java's erasure model of arrays the method above would +not work as expected -- in fact it would always return an array of +\lstinline@Object@. + +Third, in a Java environment there is a method \code{System.arraycopy} +which takes two objects as parameters together with start indices and +a length argument, and copies elements from one object to the other, +provided the objects are arrays of compatible element +types. \code{System.arraycopy} will not work for Scala's polymorphic +arrays because of their different representation. One should instead +use method \code{Array.copy} which is defined in the companion object +of class \lstinline@Array@. This companion object also defines various +constructor methods for arrays, as well as +the extractor method \code{unapplySeq} (\sref{sec:extractor-patterns}) +which enables pattern matching over arrays. +\begin{lstlisting} +package scala +object Array { + /** copies array elements from `src' to `dest'. */ + def copy(src: AnyRef, srcPos: Int, + dest: AnyRef, destPos: Int, length: Int): Unit = $\ldots$ + + /** Concatenate all argument arrays into a single array. */ + def concat[T](xs: Array[T]*): Array[T] = $\ldots$ + + /** Create a an array of successive integers. */ + def range(start: Int, end: Int): Array[Int] = $\ldots$ + + /** Create an array with given elements. */ + def apply[A <: AnyRef](xs: A*): Array[A] = $\ldots$ + + /** Analogous to above. */ + def apply(xs: Boolean*): Array[Boolean] = $\ldots$ + def apply(xs: Byte*) : Array[Byte] = $\ldots$ + def apply(xs: Short*) : Array[Short] = $\ldots$ + def apply(xs: Char*) : Array[Char] = $\ldots$ + def apply(xs: Int*) : Array[Int] = $\ldots$ + def apply(xs: Long*) : Array[Long] = $\ldots$ + def apply(xs: Float*) : Array[Float] = $\ldots$ + def apply(xs: Double*) : Array[Double] = $\ldots$ + def apply(xs: Unit*) : Array[Unit] = $\ldots$ + + /** Create an array containing several copies of an element. */ + def make[A](n: Int, elem: A): Array[A] = { + + /** Enables pattern matching over arrays */ + def unapplySeq[A](x: Array[A]): Option[Seq[A]] = Some(x) +} +\end{lstlisting} + +\example The following method duplicates a given argument array and returns a pair consisting of the original and the duplicate: +\begin{lstlisting} +def duplicate[T](xs: Array[T]) = { + val ys = new Array[T](xs.length) + Array.copy(xs, 0, ys, 0, xs.length) + (xs, ys) +} +\end{lstlisting} + +\section{Class Node}\label{cls:Node} +\begin{lstlisting} +package scala.xml + +trait Node { + + /** the label of this node */ + def label: String + + /** attribute axis */ + def attribute: Map[String, String] + + /** child axis (all children of this node) */ + def child: Seq[Node] + + /** descendant axis (all descendants of this node) */ + def descendant: Seq[Node] = child.toList.flatMap { + x => x::x.descendant.asInstanceOf[List[Node]] + } + + /** descendant axis (all descendants of this node) */ + def descendant_or_self: Seq[Node] = this::child.toList.flatMap { + x => x::x.descendant.asInstanceOf[List[Node]] + } + + override def equals(x: Any): Boolean = x match { + case that:Node => + that.label == this.label && + that.attribute.sameElements(this.attribute) && + that.child.sameElements(this.child) + case _ => false + } + + /** XPath style projection function. Returns all children of this node + * that are labeled with 'that'. The document order is preserved. + */ + def \(that: Symbol): NodeSeq = { + new NodeSeq({ + that.name match { + case "_" => child.toList + case _ => + var res:List[Node] = Nil + for (x <- child.elements if x.label == that.name) { + res = x::res + } + res.reverse + } + }) + } + + /** XPath style projection function. Returns all nodes labeled with the + * name 'that' from the 'descendant_or_self' axis. Document order is preserved. + */ + def \\(that: Symbol): NodeSeq = { + new NodeSeq( + that.name match { + case "_" => this.descendant_or_self + case _ => this.descendant_or_self.asInstanceOf[List[Node]]. + filter(x => x.label == that.name) + }) + } + + /** hashcode for this XML node */ + override def hashCode = + Utility.hashCode(label, attribute.toList.hashCode, child) + + /** string representation of this node */ + override def toString = Utility.toXML(this) + +} +\end{lstlisting} + +\newpage +\section{The \large{\code{Predef}} Object}\label{cls:predef} + +The \code{Predef} object defines standard functions and type aliases +for Scala programs. It is always implicitly imported, so that all its +defined members are available without qualification. Its definition +for the JVM environment conforms to the following signature: + +\begin{lstlisting} +package scala +object Predef { + + // classOf --------------------------------------------------------- + + /** Returns the runtime representation of a class type. */ + def classOf[T]: Class[T] = null + // this is a dummy, classOf is handled by compiler. + + // Standard type aliases --------------------------------------------- + + type String = java.lang.String + type Class[T] = java.lang.Class[T] + + // Miscellaneous ----------------------------------------------------- + + type Function[-A, +B] = Function1[A, B] + + type Map[A, +B] = collection.immutable.Map[A, B] + type Set[A] = collection.immutable.Set[A] + + val Map = collection.immutable.Map + val Set = collection.immutable.Set + + // Manifest types, companions, and incantations for summoning --------- + + type ClassManifest[T] = scala.reflect.ClassManifest[T] + type Manifest[T] = scala.reflect.Manifest[T] + type OptManifest[T] = scala.reflect.OptManifest[T] + val ClassManifest = scala.reflect.ClassManifest + val Manifest = scala.reflect.Manifest + val NoManifest = scala.reflect.NoManifest + + def manifest[T](implicit m: Manifest[T]) = m + def classManifest[T](implicit m: ClassManifest[T]) = m + def optManifest[T](implicit m: OptManifest[T]) = m + + // Minor variations on identity functions ----------------------------- + def identity[A](x: A): A = x // @see `conforms` for the implicit version + def implicitly[T](implicit e: T) = e // for summoning implicit values from the nether world + @inline def locally[T](x: T): T = x // to communicate intent and avoid unmoored statements + + // Asserts, Preconditions, Postconditions ----------------------------- + + def assert(assertion: Boolean) { + if (!assertion) + throw new java.lang.AssertionError("assertion failed") + } + + def assert(assertion: Boolean, message: => Any) { + if (!assertion) + throw new java.lang.AssertionError("assertion failed: " + message) + } + + def assume(assumption: Boolean) { + if (!assumption) + throw new IllegalArgumentException("assumption failed") + } + + def assume(assumption: Boolean, message: => Any) { + if (!assumption) + throw new IllegalArgumentException(message.toString) + } + + def require(requirement: Boolean) { + if (!requirement) + throw new IllegalArgumentException("requirement failed") + } + + def require(requirement: Boolean, message: => Any) { + if (!requirement) + throw new IllegalArgumentException("requirement failed: "+ message) + } + \end{lstlisting} +\newpage +\begin{lstlisting} + + // tupling --------------------------------------------------------- + + type Pair[+A, +B] = Tuple2[A, B] + object Pair { + def apply[A, B](x: A, y: B) = Tuple2(x, y) + def unapply[A, B](x: Tuple2[A, B]): Option[Tuple2[A, B]] = Some(x) + } + + type Triple[+A, +B, +C] = Tuple3[A, B, C] + object Triple { + def apply[A, B, C](x: A, y: B, z: C) = Tuple3(x, y, z) + def unapply[A, B, C](x: Tuple3[A, B, C]): Option[Tuple3[A, B, C]] = Some(x) + } + + // Printing and reading ----------------------------------------------- + + def print(x: Any) = Console.print(x) + def println() = Console.println() + def println(x: Any) = Console.println(x) + def printf(text: String, xs: Any*) = Console.printf(text.format(xs: _*)) + + def readLine(): String = Console.readLine() + def readLine(text: String, args: Any*) = Console.readLine(text, args) + def readBoolean() = Console.readBoolean() + def readByte() = Console.readByte() + def readShort() = Console.readShort() + def readChar() = Console.readChar() + def readInt() = Console.readInt() + def readLong() = Console.readLong() + def readFloat() = Console.readFloat() + def readDouble() = Console.readDouble() + def readf(format: String) = Console.readf(format) + def readf1(format: String) = Console.readf1(format) + def readf2(format: String) = Console.readf2(format) + def readf3(format: String) = Console.readf3(format) + + // Implict conversions ------------------------------------------------ + + ... +} +\end{lstlisting} + +\subsection{Predefined Implicit Definitions} + +The \lstinline@Predef@ object also contains a number of implicit definitions, which are available by default (because \lstinline@Predef@ is implicitly imported). +Implicit definitions come in two priorities. High-priority implicits are defined in the \lstinline@Predef@ class itself whereas low priority implicits are defined in a class inherited by \lstinline@Predef@. The rules of +static overloading resolution (\sref{sec:overloading-resolution}) +stipulate that, all other things being equal, implicit resolution +prefers high-priority implicits over low-priority ones. + +The available low-priority implicits include definitions falling into the following categories. + +\begin{enumerate} +\item +For every primitive type, a wrapper that takes values of that type +to instances of a \lstinline@runtime.Rich*@ class. For instance, values of type \lstinline@Int@ +can be implicitly converted to instances of class \lstinline@runtime.RichInt@. +\item +For every array type with elements of primitive type, a wrapper that +takes the arrays of that type to instances of a \lstinline@runtime.WrappedArray@ class. For instance, values of type \lstinline@Array[Float]@ can be implicitly converted to instances of class \lstinline@runtime.WrappedArray[Float]@. +There are also generic array wrappers that take elements +of type \lstinline@Array[T]@ for arbitrary \lstinline@T@ to \lstinline@WrappedArray@s. +\item +An implicit conversion from \lstinline@String@ to \lstinline@WrappedString@. +\end{enumerate} + +The available high-priority implicits include definitions falling into the following categories. + +\begin{itemize} +\item +An implicit wrapper that adds \lstinline@ensuring@ methods +with the following overloaded variants to type \lstinline@Any@. +\begin{lstlisting} + def ensuring(cond: Boolean): A = { assert(cond); x } + def ensuring(cond: Boolean, msg: Any): A = { assert(cond, msg); x } + def ensuring(cond: A => Boolean): A = { assert(cond(x)); x } + def ensuring(cond: A => Boolean, msg: Any): A = { assert(cond(x), msg); x } +\end{lstlisting} +\item +An implicit wrapper that adds a \lstinline@->@ method with the following implementation +to type \lstinline@Any@. +\begin{lstlisting} + def -> [B](y: B): (A, B) = (x, y) +\end{lstlisting} +\item +For every array type with elements of primitive type, a wrapper that +takes the arrays of that type to instances of a \lstinline@runtime.ArrayOps@ +class. For instance, values of type \lstinline@Array[Float]@ can be implicitly +converted to instances of class \lstinline@runtime.ArrayOps[Float]@. There are +also generic array wrappers that take elements of type \lstinline@Array[T]@ for +arbitrary \lstinline@T@ to \lstinline@ArrayOps@s. +\item +An implicit wrapper that adds \lstinline@+@ and \lstinline@formatted@ method with the following implementations +to type \lstinline@Any@. +\begin{lstlisting} + def +(other: String) = String.valueOf(self) + other + def formatted(fmtstr: String): String = fmtstr format self +\end{lstlisting} +\item +Numeric primitive conversions that implement the transitive closure of the following +mappings: + +\begin{minipage}{\linewidth} +\begin{lstlisting} + Byte -> Short + Short -> Int + Char -> Int + Int -> Long + Long -> Float + Float -> Double +\end{lstlisting} +\end{minipage} + +\item +Boxing and unboxing conversions between primitive types and their boxed versions: +\begin{lstlisting} + Byte <-> java.lang.Byte + Short <-> java.lang.Short + Char <-> java.lang.Character + Int <-> java.lang.Integer + Long <-> java.lang.Long + Float <-> java.lang.Float + Double <-> java.lang.Double + Boolean <-> java.lang.Boolean +\end{lstlisting} +\item +An implicit definition that generates instances of type \lstinline@T <:< T@, for +any type \lstinline@T@. Here, \lstinline@<:<@ is a class defined as follows. +\begin{lstlisting} + sealed abstract class <:<[-From, +To] extends (From => To) +\end{lstlisting} +Implicit parameters of \lstinline@<:<@ types are typically used to implement type constraints. +\end{itemize} + + +\comment{ +\subsection{Base Classes} +\label{sec:base-classes} + +For every template, class type and constructor invocation we define +two sets of class types: the {\em base classes} and {\em mixin base +classes}. Their definitions are as follows. + +The {\em mixin base classes} of a template +~\lstinline@$sc$ with $mt_1$ with $\ldots$ with $mt_n$ {$\stats\,$}@~ +are +the reduced union (\sref{sec:base-classes-member-defs}) of the base classes of all +mixins $mt_i$. The mixin base classes of a class type $C$ are the +mixin base classes of the template augmented by $C$ itself. The +mixin base classes of a constructor invocation of type $T$ are the +mixin base classes of class $T$. + +The {\em base classes} of a template consist are the reduced union of +the base classes of its superclass and the template's mixin base +classes. The base classes of class \lstinline@scala.Any@ consist of +just the class itself. The base classes of some other class type $C$ +are the base classes of the template represented by $C$ augmented by +$C$ itself. The base classes of a constructor invocation of type $T$ +are the base classes of $T$. + +The notions of mixin base classes and base classes are extended from +classes to arbitrary types following the definitions of +\sref{sec:base-classes-member-defs}. + +\comment{ +If two types in the base class sequence of a template refer to the +same class definition, then that definition must define a trait +(\sref{sec:traits}), and the type that comes later in the sequence must +conform to the type that comes first. +(\sref{sec:base-classes-member-defs}). +} + +\example +Consider the following class definitions: +\begin{lstlisting} +class A +class B extends A +trait C extends A +class D extends A +class E extends B with C with D +class F extends B with D with E +\end{lstlisting} +The mixin base classes and base classes of classes \code{A-F} are given in +the following table: +\begin{quote}\begin{tabular}{|l|l|l|} \hline + \ & Mixin base classes & Base classes \\ \hline +A & A & A, ScalaObject, AnyRef, Any \\ +B & B & B, A, ScalaObject, AnyRef, Any \\ +C & C & C, A, ScalaObject, AnyRef, Any \\ +D & D & D, A, ScalaObject, AnyRef, Any \\ +E & C, D, E & E, B, C, D, A, ScalaObject, AnyRef, Any \\ +F & C, D, E, F & F, B, D, E, C, A, ScalaObject, AnyRef, Any \\ \hline +\end{tabular}\end{quote} +Note that \code{D} is inherited twice by \code{F}, once directly, the +other time indirectly through \code{E}. This is permitted, since +\code{D} is a trait. +} + diff --git a/15-scala-syntax-summary.md b/15-scala-syntax-summary.md new file mode 100644 index 000000000000..2d683e351d96 --- /dev/null +++ b/15-scala-syntax-summary.md @@ -0,0 +1,2 @@ +Scala Syntax Summary +==================== \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 000000000000..4c078b8bae47 --- /dev/null +++ b/README.md @@ -0,0 +1,94 @@ +Scala Language Reference as Pandoc Markdown - Notes +=================================================== + +General +------- + +- All files must be saved as UTF-8: ensure your editors are configured + appropriately. +- Use of the appropriate unicode characters instead of the latex modifiers + for accents, etc. is necessary. For example, é instead of \'e. Make use of + the fact that the content is unicode, google the necessary characters if + you don't know how to type them directly. +- Leave two empty lines between each section, regardless of level of nesting. + Leave two empty lines at the end of every markdown file that forms a part + of the main specification when compiled. + +Conversion from LaTeX - Guidelines +---------------------------------- + +### Code + +Code blocks using the listings package of form + + \begin{lstlisting} + val x = 1 + val y = x + 1 + x + y + \end{lstlisting} + + +can be replaced with pandoc code blocks of form + + ~~~~~~~~~~~~~~{#ref-identifier .scala .numberLines} + val x = 1 + val y = x + 1 + x + y + ~~~~~~~~~~~~~~ + +Where `#ref-identifier` is an identifier that can be used for producing links +to the code block, while `.scala` and `.numberLines` are classes that get +applied to the code block for formatting purposes. At present we propose to +use the following classes: + +- `.scala` for scala code. +- `.grammar` for EBNF grammars. + +It is important to note that while math mode is supported in pandoc markdown +using the usual LaTeX convention, i.e. $x^y + z$, this does not work within +code blocks. In most cases the usages of math mode I have seen within +code blocks are easily replaced with unicode character equivalents. If +a more complex solution is required this will be investigated at a later stage. + +#### Inline Code + +Inline code, usually `~\lstinline@...some code...@` can be replaced with +the pandoc equivalent of + + `...some code...`{} + +where `` is one of the classes representing the language of the +code fragment. + +### Macro replacements: + +- The macro \U{ABCD} used for unicode character references can be + replaced with \\uABCD. +- The macro \URange{ABCD}{DCBA} used for unicode character ranges can be + replaced with \\uABCD-\\uDBCA. +- There is no adequate replacement for `\textsc{...}` (small caps) in pandoc + markdown. While unicode contains a number of small capital letters, it is + notably missing Q and X as these glyphs are intended for phonetic spelling, + therefore these cannot be reliably used. For now, the best option is to + use underscore emphasis and capitalise the text manually, `_LIKE THIS_`. +- `\code{...}` can be replaced with standard in-line verbatim markdown, + `` `like this` ``. + + +### Unicode Character replacements + +- The unicode left and right single quotation marks (‘ and ’) + have been used in place of ` and ', where the quotation marks are intended + to be paired. These can be typed on a mac using Option+] for a left quote + and Option+Shift+] for the right quote. +- Similarly for left and right double quotation marks (“ and ”) in + place of ". These can be typed on a mac using Option+[ and Option+Shift+]. + +### Enumerations + +Latex enumerations can be replaced with markdown ordered lists, which have +syntax + + #. first entry + #. ... + #. last entry \ No newline at end of file diff --git a/Scala.bib b/Scala.bib new file mode 100644 index 000000000000..cb91c4641878 --- /dev/null +++ b/Scala.bib @@ -0,0 +1,193 @@ + + +%% Article +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +@article{milner:polymorphism, + author = {Robin Milner}, + title = {A {T}heory of {T}ype {P}olymorphism in {P}rogramming}, + journal = {Journal of Computer and System Sciences}, + year = {1978}, + month = {Dec}, + volume = {17}, + pages = {348--375}, + folder = { 2-1} +} + +@Article{wirth:ebnf, + author = "Niklaus Wirth", + title = "What can we do about the unnecessary diversity of notation +for syntactic definitions?", + journal = "Comm. ACM", + year = 1977, + volume = 20, + pages = "822-823", + month = nov +} + + +%% Book +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +@Book{abelson-sussman:structure, + author = {Harold Abelson and Gerald Jay Sussman and Julie Sussman}, + title = {The Structure and Interpretation of Computer Programs, 2nd + edition}, + publisher = {MIT Press}, + address = {Cambridge, Massachusetts}, + year = {1996}, + url = {http://mitpress.mit.edu/sicp/full-text/sicp/book/book.html} +} + +@Book{goldberg-robson:smalltalk-language, + author = "Adele Goldberg and David Robson", + title = "{Smalltalk-80}; The {L}anguage and Its {I}mplementation", + publisher = "Addison-Wesley", + year = "1983", + note = "ISBN 0-201-11371-6" +} + +@Book{matsumtoto:ruby, + author = {Yukihiro Matsumoto}, + title = {Ruby in a {N}utshell}, + publisher = {O'Reilly \& Associates}, + year = "2001", + month = "nov", + note = "ISBN 0-596-00214-9" +} + +@Book{rossum:python, + author = {Guido van Rossum and Fred L. Drake}, + title = {The {P}ython {L}anguage {R}eference {M}anual}, + publisher = {Network Theory Ltd}, + year = "2003", + month = "sep", + note = {ISBN 0-954-16178-5\hspace*{\fill}\\ + \verb@http://www.python.org/doc/current/ref/ref.html@} +} + +@Manual{odersky:scala-reference, + title = {The {S}cala {L}anguage {S}pecification, Version 2.4}, + author = {Martin Odersky}, + organization = {EPFL}, + month = feb, + year = 2007, + note = {http://www.scala-lang.org/docu/manuals.html} +} + +@Book{odersky:scala-reference, + ALTauthor = {Martin Odersky}, + ALTeditor = {}, + title = {The {S}cala {L}anguage {S}pecification, Version 2.4}, + publisher = {}, + year = {}, + OPTkey = {}, + OPTvolume = {}, + OPTnumber = {}, + OPTseries = {}, + OPTaddress = {}, + OPTedition = {}, + OPTmonth = {}, + OPTnote = {}, + OPTannote = {} +} + + +%% InProceedings +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +@InProceedings{odersky-et-al:fool10, + author = {Martin Odersky and Vincent Cremet and Christine R\"ockl + and Matthias Zenger}, + title = {A {N}ominal {T}heory of {O}bjects with {D}ependent {T}ypes}, + booktitle = {Proc. FOOL 10}, + year = 2003, + month = jan, + note = {\hspace*{\fill}\\ + \verb@http://www.cis.upenn.edu/~bcpierce/FOOL/FOOL10.html@} +} + + +%% Misc +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +@Misc{w3c:dom, + author = {W3C}, + title = {Document Object Model ({DOM})}, + howpublished = {\hspace*{\fill}\\ + \verb@http://www.w3.org/DOM/@} +} + +@Misc{w3c:xml, + author = {W3C}, + title = {Extensible {M}arkup {L}anguage ({XML})}, + howpublished = {\hspace*{\fill}\\ + \verb@http://www.w3.org/TR/REC-xml@} +} + +@TechReport{scala-overview-tech-report, + author = {Martin Odersky and al.}, + title = {An {O}verview of the {S}cala {P}rogramming {L}anguage}, + institution = {EPFL Lausanne, Switzerland}, + year = 2004, + number = {IC/2004/64} +} + +@InProceedings{odersky:sca, + author = {Martin Odersky and Matthias Zenger}, + title = {Scalable {C}omponent {A}bstractions}, + booktitle = {Proc. OOPSLA}, + year = 2005 +} + +@InProceedings{odersky-et-al:ecoop03, + author = {Martin Odersky and Vincent Cremet and Christine R\"ockl and Matthias Zenger}, + title = {A {N}ominal {T}heory of {O}bjects with {D}ependent {T}ypes}, + booktitle = {Proc. ECOOP'03}, + year = 2003, + month = jul, + series = {Springer LNCS} +} + +@InCollection{cremet-odersky:pilib, + author = {Vincent Cremet and Martin Odersky}, + title = {{PiLib} - A {H}osted {L}anguage for {P}i-{C}alculus {S}tyle {C}oncurrency}, + booktitle = {Domain-Specific Program Generation}, + publisher = {Springer}, + year = 2005, + volume = 3016, + series = {Lecture Notes in Computer Science} +} + +@InProceedings{odersky-zenger:fool12, + author = {Martin Odersky and Matthias Zenger}, + title = {Independently {E}xtensible {S}olutions to the {E}xpression {P}roblem}, + booktitle = {Proc. FOOL 12}, + year = 2005, + month = jan, + note = {\verb@http://homepages.inf.ed.ac.uk/wadler/fool@} +} + +@InProceedings{odersky:scala-experiment, + author = {Martin Odersky}, + title = {The {S}cala {E}xperiment -- {C}an {W}e {P}rovide {B}etter {L}anguage {S}upport for {C}omponent {S}ystems?}, + booktitle = {Proc. ACM Symposium on Principles of Programming Languages}, + year = 2006 +} + +@MISC{kennedy-pierce:decidable, + author = {Andrew J. Kennedy and Benjamin C. Pierce}, + title = {On {D}ecidability of {N}ominal {S}ubtyping with {V}ariance}, + year = {2007}, + month = jan, + note = {FOOL-WOOD '07}, + short = {http://www.cis.upenn.edu/~bcpierce/papers/variance.pdf} +} + +@Misc{spec-sid, + author = {Iulian Dragos}, + title = {Scala Specialization}, + year = 2010, + note = {SID-9} +} + diff --git a/build.sh b/build.sh new file mode 100755 index 000000000000..f3973b7d845c --- /dev/null +++ b/build.sh @@ -0,0 +1,42 @@ +#!/bin/sh +find . -name "*.md" | \ +cat 01-title.md \ + 02-preface.md \ + 03-lexical-syntax.md > build/ScalaReference.md +# 04-identifiers-names-and-scopes.md \ +# 05-types.md \ +# 06-basic-declarations-and-definitions.md \ +# 07-classes-and-objects.md \ +# 08-expressions.md \ +# 09-implicit-parameters-and-views.md \ +# 10-pattern-matching.md \ +# 11-top-level-definitions.md \ +# 12-xml-expressions-and-patterns.md \ +# 13-user-defined-annotations.md \ +# 14-the-scala-standard-library.md \ +# 15-scala-syntax-summary.md \ + +pandoc -f markdown \ + -t html5 \ + --standalone \ + --toc \ + --chapters \ + --number-sections \ + --bibliography=Scala.bib \ + --template=resources/scala-ref-template.html5 \ + --self-contained \ + --mathml \ + -o build/ScalaReference.html \ + build/ScalaReference.md + +# pdf generation - not working yet +#pandoc -f markdown \ +# --standalone \ +# --toc \ +# --chapters \ +# --number-sections \ +# --bibliography=Scala.bib \ +# --self-contained \ +# --latex-engine=xelatex \ +# -o build/ScalaReference.pdf \ +# build/ScalaReference.panmd \ No newline at end of file diff --git a/resources/blueprint-print.css b/resources/blueprint-print.css new file mode 100755 index 000000000000..bd79afdea558 --- /dev/null +++ b/resources/blueprint-print.css @@ -0,0 +1,29 @@ +/* ----------------------------------------------------------------------- + + + Blueprint CSS Framework 1.0.1 + http://blueprintcss.org + + * Copyright (c) 2007-Present. See LICENSE for more info. + * See README for instructions on how to use Blueprint. + * For credits and origins, see AUTHORS. + * This is a compressed file. See the sources in the 'src' directory. + +----------------------------------------------------------------------- */ + +/* print.css */ +body {line-height:1.5;font-family:"Helvetica Neue", Arial, Helvetica, sans-serif;color:#000;background:none;font-size:10pt;} +.container {background:none;} +hr {background:#ccc;color:#ccc;width:100%;height:2px;margin:2em 0;padding:0;border:none;} +hr.space {background:#fff;color:#fff;visibility:hidden;} +h1, h2, h3, h4, h5, h6 {font-family:"Helvetica Neue", Arial, "Lucida Grande", sans-serif;} +code {font:.9em "Courier New", Monaco, Courier, monospace;} +a img {border:none;} +p img.top {margin-top:0;} +blockquote {margin:1.5em;padding:1em;font-style:italic;font-size:.9em;} +.small {font-size:.9em;} +.large {font-size:1.1em;} +.quiet {color:#999;} +.hide {display:none;} +a:link, a:visited {background:transparent;font-weight:700;text-decoration:underline;} +a:link:after, a:visited:after {content:" (" attr(href) ")";font-size:90%;} \ No newline at end of file diff --git a/resources/blueprint-screen.css b/resources/blueprint-screen.css new file mode 100755 index 000000000000..593609aa45d1 --- /dev/null +++ b/resources/blueprint-screen.css @@ -0,0 +1,265 @@ +/* ----------------------------------------------------------------------- + + + Blueprint CSS Framework 1.0.1 + http://blueprintcss.org + + * Copyright (c) 2007-Present. See LICENSE for more info. + * See README for instructions on how to use Blueprint. + * For credits and origins, see AUTHORS. + * This is a compressed file. See the sources in the 'src' directory. + +----------------------------------------------------------------------- */ + +/* reset.css */ +html {margin:0;padding:0;border:0;} +body, div, span, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, code, del, dfn, em, img, q, dl, dt, dd, ol, ul, li, fieldset, form, label, legend, table, caption, tbody, tfoot, thead, tr, th, td, article, aside, dialog, figure, footer, header, hgroup, nav, section {margin:0;padding:0;border:0;font-size:100%;font:inherit;vertical-align:baseline;} +article, aside, details, figcaption, figure, dialog, footer, header, hgroup, menu, nav, section {display:block;} +body {line-height:1.5;background:white;} +table {border-collapse:separate;border-spacing:0;} +caption, th, td {text-align:left;font-weight:normal;float:none !important;} +table, th, td {vertical-align:middle;} +blockquote:before, blockquote:after, q:before, q:after {content:'';} +blockquote, q {quotes:"" "";} +a img {border:none;} +:focus {outline:0;} + +/* typography.css */ +html {font-size:100.01%;} +body {font-size:75%;color:#222;background:#fff;font-family:"Helvetica Neue", Arial, Helvetica, sans-serif;} +h1, h2, h3, h4, h5, h6 {font-weight:normal;color:#111;} +h1 {font-size:3em;line-height:1;margin-bottom:0.5em;} +h2 {font-size:2em;margin-bottom:0.75em;} +h3 {font-size:1.5em;line-height:1;margin-bottom:1em;} +h4 {font-size:1.2em;line-height:1.25;margin-bottom:1.25em;} +h5 {font-size:1em;font-weight:bold;margin-bottom:1.5em;} +h6 {font-size:1em;font-weight:bold;} +h1 img, h2 img, h3 img, h4 img, h5 img, h6 img {margin:0;} +p {margin:0 0 1.5em;} +.left {float:left !important;} +p .left {margin:1.5em 1.5em 1.5em 0;padding:0;} +.right {float:right !important;} +p .right {margin:1.5em 0 1.5em 1.5em;padding:0;} +a:focus, a:hover {color:#09f;} +a {color:#06c;text-decoration:underline;} +blockquote {margin:1.5em;color:#666;font-style:italic;} +strong, dfn {font-weight:bold;} +em, dfn {font-style:italic;} +sup, sub {line-height:0;} +abbr, acronym {border-bottom:1px dotted #666;} +address {margin:0 0 1.5em;font-style:italic;} +del {color:#666;} +pre {margin:1.5em 0;white-space:pre;} +pre, code, tt {font:1em 'andale mono', 'lucida console', monospace;line-height:1.5;} +li ul, li ol {margin:0;} +ul, ol {margin:0 1.5em 1.5em 0;padding-left:1.5em;} +ul {list-style-type:disc;} +ol {list-style-type:decimal;} +dl {margin:0 0 1.5em 0;} +dl dt {font-weight:bold;} +dd {margin-left:1.5em;} +table {margin-bottom:1.4em;width:100%;} +th {font-weight:bold;} +thead th {background:#c3d9ff;} +th, td, caption {padding:4px 10px 4px 5px;} +tbody tr:nth-child(even) td, tbody tr.even td {background:#e5ecf9;} +tfoot {font-style:italic;} +caption {background:#eee;} +.small {font-size:.8em;margin-bottom:1.875em;line-height:1.875em;} +.large {font-size:1.2em;line-height:2.5em;margin-bottom:1.25em;} +.hide {display:none;} +.quiet {color:#666;} +.loud {color:#000;} +.highlight {background:#ff0;} +.added {background:#060;color:#fff;} +.removed {background:#900;color:#fff;} +.first {margin-left:0;padding-left:0;} +.last {margin-right:0;padding-right:0;} +.top {margin-top:0;padding-top:0;} +.bottom {margin-bottom:0;padding-bottom:0;} + +/* forms.css */ +label {font-weight:bold;} +fieldset {padding:0 1.4em 1.4em 1.4em;margin:0 0 1.5em 0;border:1px solid #ccc;} +legend {font-weight:bold;font-size:1.2em;margin-top:-0.2em;margin-bottom:1em;} +fieldset, #IE8#HACK {padding-top:1.4em;} +legend, #IE8#HACK {margin-top:0;margin-bottom:0;} +input[type=text], input[type=password], input[type=url], input[type=email], input.text, input.title, textarea {background-color:#fff;border:1px solid #bbb;color:#000;} +input[type=text]:focus, input[type=password]:focus, input[type=url]:focus, input[type=email]:focus, input.text:focus, input.title:focus, textarea:focus {border-color:#666;} +select {background-color:#fff;border-width:1px;border-style:solid;} +input[type=text], input[type=password], input[type=url], input[type=email], input.text, input.title, textarea, select {margin:0.5em 0;} +input.text, input.title {width:300px;padding:5px;} +input.title {font-size:1.5em;} +textarea {width:390px;height:250px;padding:5px;} +form.inline {line-height:3;} +form.inline p {margin-bottom:0;} +.error, .alert, .notice, .success, .info {padding:0.8em;margin-bottom:1em;border:2px solid #ddd;} +.error, .alert {background:#fbe3e4;color:#8a1f11;border-color:#fbc2c4;} +.notice {background:#fff6bf;color:#514721;border-color:#ffd324;} +.success {background:#e6efc2;color:#264409;border-color:#c6d880;} +.info {background:#d5edf8;color:#205791;border-color:#92cae4;} +.error a, .alert a {color:#8a1f11;} +.notice a {color:#514721;} +.success a {color:#264409;} +.info a {color:#205791;} + +/* grid.css */ +.container {width:950px;margin:0 auto;} +.showgrid {background:url(grid.png);} +.column, .span-1, .span-2, .span-3, .span-4, .span-5, .span-6, .span-7, .span-8, .span-9, .span-10, .span-11, .span-12, .span-13, .span-14, .span-15, .span-16, .span-17, .span-18, .span-19, .span-20, .span-21, .span-22, .span-23, .span-24 {float:left;margin-right:10px;} +.last {margin-right:0;} +.span-1 {width:30px;} +.span-2 {width:70px;} +.span-3 {width:110px;} +.span-4 {width:150px;} +.span-5 {width:190px;} +.span-6 {width:230px;} +.span-7 {width:270px;} +.span-8 {width:310px;} +.span-9 {width:350px;} +.span-10 {width:390px;} +.span-11 {width:430px;} +.span-12 {width:470px;} +.span-13 {width:510px;} +.span-14 {width:550px;} +.span-15 {width:590px;} +.span-16 {width:630px;} +.span-17 {width:670px;} +.span-18 {width:710px;} +.span-19 {width:750px;} +.span-20 {width:790px;} +.span-21 {width:830px;} +.span-22 {width:870px;} +.span-23 {width:910px;} +.span-24 {width:950px;margin-right:0;} +input.span-1, textarea.span-1, input.span-2, textarea.span-2, input.span-3, textarea.span-3, input.span-4, textarea.span-4, input.span-5, textarea.span-5, input.span-6, textarea.span-6, input.span-7, textarea.span-7, input.span-8, textarea.span-8, input.span-9, textarea.span-9, input.span-10, textarea.span-10, input.span-11, textarea.span-11, input.span-12, textarea.span-12, input.span-13, textarea.span-13, input.span-14, textarea.span-14, input.span-15, textarea.span-15, input.span-16, textarea.span-16, input.span-17, textarea.span-17, input.span-18, textarea.span-18, input.span-19, textarea.span-19, input.span-20, textarea.span-20, input.span-21, textarea.span-21, input.span-22, textarea.span-22, input.span-23, textarea.span-23, input.span-24, textarea.span-24 {border-left-width:1px;border-right-width:1px;padding-left:5px;padding-right:5px;} +input.span-1, textarea.span-1 {width:18px;} +input.span-2, textarea.span-2 {width:58px;} +input.span-3, textarea.span-3 {width:98px;} +input.span-4, textarea.span-4 {width:138px;} +input.span-5, textarea.span-5 {width:178px;} +input.span-6, textarea.span-6 {width:218px;} +input.span-7, textarea.span-7 {width:258px;} +input.span-8, textarea.span-8 {width:298px;} +input.span-9, textarea.span-9 {width:338px;} +input.span-10, textarea.span-10 {width:378px;} +input.span-11, textarea.span-11 {width:418px;} +input.span-12, textarea.span-12 {width:458px;} +input.span-13, textarea.span-13 {width:498px;} +input.span-14, textarea.span-14 {width:538px;} +input.span-15, textarea.span-15 {width:578px;} +input.span-16, textarea.span-16 {width:618px;} +input.span-17, textarea.span-17 {width:658px;} +input.span-18, textarea.span-18 {width:698px;} +input.span-19, textarea.span-19 {width:738px;} +input.span-20, textarea.span-20 {width:778px;} +input.span-21, textarea.span-21 {width:818px;} +input.span-22, textarea.span-22 {width:858px;} +input.span-23, textarea.span-23 {width:898px;} +input.span-24, textarea.span-24 {width:938px;} +.append-1 {padding-right:40px;} +.append-2 {padding-right:80px;} +.append-3 {padding-right:120px;} +.append-4 {padding-right:160px;} +.append-5 {padding-right:200px;} +.append-6 {padding-right:240px;} +.append-7 {padding-right:280px;} +.append-8 {padding-right:320px;} +.append-9 {padding-right:360px;} +.append-10 {padding-right:400px;} +.append-11 {padding-right:440px;} +.append-12 {padding-right:480px;} +.append-13 {padding-right:520px;} +.append-14 {padding-right:560px;} +.append-15 {padding-right:600px;} +.append-16 {padding-right:640px;} +.append-17 {padding-right:680px;} +.append-18 {padding-right:720px;} +.append-19 {padding-right:760px;} +.append-20 {padding-right:800px;} +.append-21 {padding-right:840px;} +.append-22 {padding-right:880px;} +.append-23 {padding-right:920px;} +.prepend-1 {padding-left:40px;} +.prepend-2 {padding-left:80px;} +.prepend-3 {padding-left:120px;} +.prepend-4 {padding-left:160px;} +.prepend-5 {padding-left:200px;} +.prepend-6 {padding-left:240px;} +.prepend-7 {padding-left:280px;} +.prepend-8 {padding-left:320px;} +.prepend-9 {padding-left:360px;} +.prepend-10 {padding-left:400px;} +.prepend-11 {padding-left:440px;} +.prepend-12 {padding-left:480px;} +.prepend-13 {padding-left:520px;} +.prepend-14 {padding-left:560px;} +.prepend-15 {padding-left:600px;} +.prepend-16 {padding-left:640px;} +.prepend-17 {padding-left:680px;} +.prepend-18 {padding-left:720px;} +.prepend-19 {padding-left:760px;} +.prepend-20 {padding-left:800px;} +.prepend-21 {padding-left:840px;} +.prepend-22 {padding-left:880px;} +.prepend-23 {padding-left:920px;} +.border {padding-right:4px;margin-right:5px;border-right:1px solid #ddd;} +.colborder {padding-right:24px;margin-right:25px;border-right:1px solid #ddd;} +.pull-1 {margin-left:-40px;} +.pull-2 {margin-left:-80px;} +.pull-3 {margin-left:-120px;} +.pull-4 {margin-left:-160px;} +.pull-5 {margin-left:-200px;} +.pull-6 {margin-left:-240px;} +.pull-7 {margin-left:-280px;} +.pull-8 {margin-left:-320px;} +.pull-9 {margin-left:-360px;} +.pull-10 {margin-left:-400px;} +.pull-11 {margin-left:-440px;} +.pull-12 {margin-left:-480px;} +.pull-13 {margin-left:-520px;} +.pull-14 {margin-left:-560px;} +.pull-15 {margin-left:-600px;} +.pull-16 {margin-left:-640px;} +.pull-17 {margin-left:-680px;} +.pull-18 {margin-left:-720px;} +.pull-19 {margin-left:-760px;} +.pull-20 {margin-left:-800px;} +.pull-21 {margin-left:-840px;} +.pull-22 {margin-left:-880px;} +.pull-23 {margin-left:-920px;} +.pull-24 {margin-left:-960px;} +.pull-1, .pull-2, .pull-3, .pull-4, .pull-5, .pull-6, .pull-7, .pull-8, .pull-9, .pull-10, .pull-11, .pull-12, .pull-13, .pull-14, .pull-15, .pull-16, .pull-17, .pull-18, .pull-19, .pull-20, .pull-21, .pull-22, .pull-23, .pull-24 {float:left;position:relative;} +.push-1 {margin:0 -40px 1.5em 40px;} +.push-2 {margin:0 -80px 1.5em 80px;} +.push-3 {margin:0 -120px 1.5em 120px;} +.push-4 {margin:0 -160px 1.5em 160px;} +.push-5 {margin:0 -200px 1.5em 200px;} +.push-6 {margin:0 -240px 1.5em 240px;} +.push-7 {margin:0 -280px 1.5em 280px;} +.push-8 {margin:0 -320px 1.5em 320px;} +.push-9 {margin:0 -360px 1.5em 360px;} +.push-10 {margin:0 -400px 1.5em 400px;} +.push-11 {margin:0 -440px 1.5em 440px;} +.push-12 {margin:0 -480px 1.5em 480px;} +.push-13 {margin:0 -520px 1.5em 520px;} +.push-14 {margin:0 -560px 1.5em 560px;} +.push-15 {margin:0 -600px 1.5em 600px;} +.push-16 {margin:0 -640px 1.5em 640px;} +.push-17 {margin:0 -680px 1.5em 680px;} +.push-18 {margin:0 -720px 1.5em 720px;} +.push-19 {margin:0 -760px 1.5em 760px;} +.push-20 {margin:0 -800px 1.5em 800px;} +.push-21 {margin:0 -840px 1.5em 840px;} +.push-22 {margin:0 -880px 1.5em 880px;} +.push-23 {margin:0 -920px 1.5em 920px;} +.push-24 {margin:0 -960px 1.5em 960px;} +.push-1, .push-2, .push-3, .push-4, .push-5, .push-6, .push-7, .push-8, .push-9, .push-10, .push-11, .push-12, .push-13, .push-14, .push-15, .push-16, .push-17, .push-18, .push-19, .push-20, .push-21, .push-22, .push-23, .push-24 {float:left;position:relative;} +div.prepend-top, .prepend-top {margin-top:1.5em;} +div.append-bottom, .append-bottom {margin-bottom:1.5em;} +.box {padding:1.5em;margin-bottom:1.5em;background:#e5eCf9;} +hr {background:#ddd;color:#ddd;clear:both;float:none;width:100%;height:1px;margin:0 0 17px;border:none;} +hr.space {background:#fff;color:#fff;visibility:hidden;} +.clearfix:after, .container:after {content:"\0020";display:block;height:0;clear:both;visibility:hidden;overflow:hidden;} +.clearfix, .container {display:block;} +.clear {clear:both;} \ No newline at end of file diff --git a/resources/grid.png b/resources/grid.png new file mode 100755 index 0000000000000000000000000000000000000000..4ceb11042608204d733ab76868b062f9cc0c76b2 GIT binary patch literal 104 zcmeAS@N?(olHy`uVBq!ia0vp^8bB<>#0(@u3QJ6Z6lZ`>i0g~@zhAz5`Tzg_MyHUO zKtU-_7srr_Imt;44C_Ky&yaYKkYV7gc%b@g7K2I&YxzWL#ay5&22WQ%mvv4FO#siN BAS?g? literal 0 HcmV?d00001 diff --git a/resources/ie.css b/resources/ie.css new file mode 100755 index 000000000000..f01539959a41 --- /dev/null +++ b/resources/ie.css @@ -0,0 +1,36 @@ +/* ----------------------------------------------------------------------- + + + Blueprint CSS Framework 1.0.1 + http://blueprintcss.org + + * Copyright (c) 2007-Present. See LICENSE for more info. + * See README for instructions on how to use Blueprint. + * For credits and origins, see AUTHORS. + * This is a compressed file. See the sources in the 'src' directory. + +----------------------------------------------------------------------- */ + +/* ie.css */ +body {text-align:center;} +.container {text-align:left;} +* html .column, * html .span-1, * html .span-2, * html .span-3, * html .span-4, * html .span-5, * html .span-6, * html .span-7, * html .span-8, * html .span-9, * html .span-10, * html .span-11, * html .span-12, * html .span-13, * html .span-14, * html .span-15, * html .span-16, * html .span-17, * html .span-18, * html .span-19, * html .span-20, * html .span-21, * html .span-22, * html .span-23, * html .span-24 {display:inline;overflow-x:hidden;} +* html legend {margin:0px -8px 16px 0;padding:0;} +sup {vertical-align:text-top;} +sub {vertical-align:text-bottom;} +html>body p code {*white-space:normal;} +hr {margin:-8px auto 11px;} +img {-ms-interpolation-mode:bicubic;} +.clearfix, .container {display:inline-block;} +* html .clearfix, * html .container {height:1%;} +fieldset {padding-top:0;} +legend {margin-top:-0.2em;margin-bottom:1em;margin-left:-0.5em;} +textarea {overflow:auto;} +label {vertical-align:middle;position:relative;top:-0.25em;} +input.text, input.title, textarea {background-color:#fff;border:1px solid #bbb;} +input.text:focus, input.title:focus {border-color:#666;} +input.text, input.title, textarea, select {margin:0.5em 0;} +input.checkbox, input.radio {position:relative;top:.25em;} +form.inline div, form.inline p {vertical-align:middle;} +form.inline input.checkbox, form.inline input.radio, form.inline input.button, form.inline button {margin:0.5em 0;} +button, input.button {position:relative;top:0.25em;} \ No newline at end of file diff --git a/resources/scala-ref-template.html5 b/resources/scala-ref-template.html5 new file mode 100644 index 000000000000..33d6b26ef843 --- /dev/null +++ b/resources/scala-ref-template.html5 @@ -0,0 +1,69 @@ + + + + + +$for(author-meta)$ + +$endfor$ +$if(date-meta)$ + +$endif$ + $if(title-prefix)$$title-prefix$ - $endif$$if(pagetitle)$$pagetitle$$endif$ + +$if(quotes)$ + +$endif$ +$if(highlighting-css)$ + +$endif$ +$for(css)$ + +$endfor$ +$if(math)$ + $math$ +$endif$ +$for(header-includes)$ + $header-includes$ +$endfor$ + + + + + + + + +
+$for(include-before)$ +$include-before$ +$endfor$ +$if(title)$ +
+

$title$

+$if(date)$ +

$date$

+$endif$ +
+
+$endif$ +$if(toc)$ + +$endif$ +$body$ +$for(include-after)$ +$include-after$ +$endfor$ +
+ + diff --git a/resources/style.css b/resources/style.css new file mode 100644 index 000000000000..04e953658ef6 --- /dev/null +++ b/resources/style.css @@ -0,0 +1,28 @@ +header h1 { + text-align: center; +} + +header .date { + text-align: center; +} + +.container > h1 a, +.container > h2 a, +.container > h3 a, +.container > h4 a, +.container > h5 a, +.container > h6 a { + text-decoration: none; + color: #111; +} + +pre { + margin-left: 3em; + padding: 1em; + background-color: #EEE; + border: 1px solid #333; +} + +code { + background-color: #EEE; +} From 4f86c27395ed08e989db9e2280cee01699075924 Mon Sep 17 00:00:00 2001 From: Iain McGinniss Date: Thu, 18 Oct 2012 09:37:45 +0100 Subject: [PATCH 002/826] fixed missing newline between example text and delimited code expression --- 03-lexical-syntax.md | 1 + 1 file changed, 1 insertion(+) diff --git a/03-lexical-syntax.md b/03-lexical-syntax.md index 6153b3876443..519094ac2cd2 100644 --- a/03-lexical-syntax.md +++ b/03-lexical-syntax.md @@ -441,6 +441,7 @@ i.e. `"\""`. The value of a string literal is an instance of class `String`{.scala}. (@) Here are some string literals: + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} "Hello,\nWorld!" "This string contains a \" character." From 82435f103db0ede9665dcd2c15d5759c5aacac2d Mon Sep 17 00:00:00 2001 From: Iain McGinniss Date: Thu, 18 Oct 2012 09:39:12 +0100 Subject: [PATCH 003/826] experimental restyling of examples to try and look a bit more like the original spec. --- resources/style.css | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/resources/style.css b/resources/style.css index 04e953658ef6..b0230de74880 100644 --- a/resources/style.css +++ b/resources/style.css @@ -26,3 +26,11 @@ pre { code { background-color: #EEE; } + +ol[type="1"] { + list-style-type: none; +} + +ol[type="1"] li:before { + content: "Example "; +} \ No newline at end of file From 7c16776236dcf1d34551916dedefc22cfdc3f999 Mon Sep 17 00:00:00 2001 From: Iain McGinniss Date: Thu, 18 Oct 2012 13:41:28 +0100 Subject: [PATCH 004/826] removed some stray LaTeX commands from Lexical Syntax chapter, and a back-reference from the expressions chapter. --- 03-lexical-syntax.md | 16 +++++++--------- 08-expressions.md | 2 +- 2 files changed, 8 insertions(+), 10 deletions(-) diff --git a/03-lexical-syntax.md b/03-lexical-syntax.md index 519094ac2cd2..c8d031bba64e 100644 --- a/03-lexical-syntax.md +++ b/03-lexical-syntax.md @@ -9,7 +9,7 @@ otherwise mentioned, the following descriptions of Scala tokens refer to Scala mode, and literal characters ‘c’ refer to the ASCII fragment \\u0000-\\u007F -In Scala mode, \textit{Unicode escapes} are replaced by the corresponding +In Scala mode, _Unicode escapes_ are replaced by the corresponding Unicode character with the given hexadecimal code. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} @@ -43,7 +43,7 @@ plainid ::= upper idrest | varid | op id ::= plainid - | ‘\`’ stringLit ‘\`’ + | ‘`’ stringLit ‘`’ idrest ::= {letter | digit} [‘_’ op] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -296,8 +296,6 @@ protected class Data { ... } Literals ---------- -\label{sec:literals} - There are literals for integer numbers, floating point numbers, characters, booleans, symbols, strings. The syntax of these literals is in each case as in Java. @@ -326,8 +324,8 @@ decimalNumeral ::= ‘0’ | nonZeroDigit {digit} hexNumeral ::= ‘0’ ‘x’ hexDigit {hexDigit} octalNumeral ::= ‘0’ octalDigit {octalDigit} digit ::= ‘0’ | nonZeroDigit -nonZeroDigit ::= ‘1’ | $\cdots$ | ‘9’ -octalDigit ::= ‘0’ | $\cdots$ | ‘7’ +nonZeroDigit ::= ‘1’ | … | ‘9’ +octalDigit ::= ‘0’ | … | ‘7’ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Integer literals are usually of type `Int`{.scala}, or of type @@ -484,8 +482,8 @@ The expression ~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} """the present string - |spans three - |lines.""".stripMargin + spans three + lines.""".stripMargin ~~~~~~~~~~~~~~~~~~~~~~~~~~ evaluates to @@ -578,7 +576,7 @@ brace and immediately followed by a character starting an XML name. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} ( whitespace | ‘(’ | ‘{’ ) ‘<’ (XNameStart | ‘!’ | ‘?’) - XNameStart ::= ‘_’ | BaseChar | Ideographic $\mbox{\rm\em (as in W3C XML, but without }$ ‘:’ + XNameStart ::= ‘_’ | BaseChar | Ideographic // as in W3C XML, but without ‘:’ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The scanner switches from XML mode to Scala mode if either diff --git a/08-expressions.md b/08-expressions.md index 928b56868b15..77eec052b4d0 100644 --- a/08-expressions.md +++ b/08-expressions.md @@ -78,7 +78,7 @@ $T$ forSome { type $t_1[\tps_1] >: L_1 <: U_1$; $\ldots$; type $t_n[\tps_n] >: L SimpleExpr ::= Literal \end{lstlisting} -Typing of literals is as described in (\sref{sec:literals}); their +Typing of literals is as described [here](#literals); their evaluation is immediate. From f938a7c834f4abe835048063306af6010a60c73c Mon Sep 17 00:00:00 2001 From: Iain McGinniss Date: Fri, 19 Oct 2012 20:14:04 +0100 Subject: [PATCH 005/826] Identifiers, Names and Scopes chapter converted. Minor CSS tweaks to make examples and inline code look better. --- 04-identifiers-names-and-scopes.md | 159 +++++++++++++++-------------- build.sh | 4 +- resources/style.css | 13 +++ 3 files changed, 97 insertions(+), 79 deletions(-) diff --git a/04-identifiers-names-and-scopes.md b/04-identifiers-names-and-scopes.md index 2d0ba8b65ff2..6a7393db94be 100644 --- a/04-identifiers-names-and-scopes.md +++ b/04-identifiers-names-and-scopes.md @@ -2,97 +2,102 @@ Identifiers, Names and Scopes ============================= Names in Scala identify types, values, methods, and classes which are -collectively called {\em entities}. Names are introduced by local -definitions and declarations (\sref{sec:defs}), inheritance (\sref{sec:members}), -import clauses (\sref{sec:import}), or package clauses -(\sref{sec:packagings}) which are collectively called {\em -bindings}. +collectively called _entities_. Names are introduced by local +[definitions and declarations](#basic-declarations-and-definitions), +[inheritance](#class-members), +[import clauses](#import-clauses), or +[package clauses](#packagings) +which are collectively called _bindings_. Bindings of different kinds have a precedence defined on them: -\begin{enumerate} -\item Definitions and declarations that are local, inherited, or made -available by a package clause in the same compilation unit where the -definition occurs have highest precedence. -\item Explicit imports have next highest precedence. -\item Wildcard imports have next highest precedence. -\item Definitions made available by a package clause not in the -compilation unit where the definition occurs have lowest precedence. -\end{enumerate} - -There are two different name spaces, one for types (\sref{sec:types}) -and one for terms (\sref{sec:exprs}). The same name may designate a + +#. Definitions and declarations that are local, inherited, or made + available by a package clause in the same compilation unit where the + definition occurs have highest precedence. +#. Explicit imports have next highest precedence. +#. Wildcard imports have next highest precedence. +#. Definitions made available by a package clause not in the + compilation unit where the definition occurs have lowest precedence. + + +There are two different name spaces, one for [types](#types) +and one for [terms](#expressions). The same name may designate a type and a term, depending on the context where the name is used. -A binding has a {\em scope} in which the entity defined by a single +A binding has a _scope_ in which the entity defined by a single name can be accessed using a simple name. Scopes are nested. A binding -in some inner scope {\em shadows} bindings of lower precedence in the +in some inner scope _shadows_ bindings of lower precedence in the same scope as well as bindings of the same or lower precedence in outer scopes. Note that shadowing is only a partial order. In a situation like -\begin{lstlisting} + +~~~~~~~~~~~~~~ {.scala} val x = 1; { import p.x; x } -\end{lstlisting} -neither binding of \code{x} shadows the other. Consequently, the -reference to \code{x} in the third line above would be ambiguous. +~~~~~~~~~~~~~~ + +neither binding of `x` shadows the other. Consequently, the +reference to `x` in the third line above would be ambiguous. -A reference to an unqualified (type- or term-) identifier $x$ is bound +A reference to an unqualified (type- or term-) identifier _x_ is bound by the unique binding, which -\begin{itemize} -\item defines an entity with name $x$ in the same namespace as the -identifier, and -\item shadows all other bindings that define entities with name $x$ in that namespace. -\end{itemize} -It is an error if no such binding exists. If $x$ is bound by an -import clause, then the simple name $x$ is taken to be equivalent to -the qualified name to which $x$ is mapped by the import clause. If $x$ -is bound by a definition or declaration, then $x$ refers to the entity -introduced by that binding. In that case, the type of $x$ is the type + +- defines an entity with name $x$ in the same namespace as the identifier, and +- shadows all other bindings that define entities with name _x_ in that + namespace. + +It is an error if no such binding exists. If _x_ is bound by an +import clause, then the simple name _x_ is taken to be equivalent to +the qualified name to which _x_ is mapped by the import clause. If _x_ +is bound by a definition or declaration, then _x_ refers to the entity +introduced by that binding. In that case, the type of _x_ is the type of the referenced entity. -\example Assume the following two definitions of a objects named \lstinline@X@ in packages \lstinline@P@ and \lstinline@Q@. -%ref: shadowing.scala -\begin{lstlisting} -package P { - object X { val x = 1; val y = 2 } -} -\end{lstlisting} -\begin{lstlisting} -package Q { - object X { val x = true; val y = "" } -} -\end{lstlisting} -The following program illustrates different kinds of bindings and -precedences between them. -\begin{lstlisting} -package P { // `X' bound by package clause -import Console._ // `println' bound by wildcard import -object A { - println("L4: "+X) // `X' refers to `P.X' here - object B { - import Q._ // `X' bound by wildcard import - println("L7: "+X) // `X' refers to `Q.X' here - import X._ // `x' and `y' bound by wildcard import - println("L8: "+x) // `x' refers to `Q.X.x' here - object C { - val x = 3 // `x' bound by local definition - println("L12: "+x) // `x' refers to constant `3' here - { import Q.X._ // `x' and `y' bound by wildcard import -// println("L14: "+x) // reference to `x' is ambiguous here - import X.y // `y' bound by explicit import - println("L16: "+y) // `y' refers to `Q.X.y' here - { val x = "abc" // `x' bound by local definition - import P.X._ // `x' and `y' bound by wildcard import -// println("L19: "+y) // reference to `y' is ambiguous here - println("L20: "+x) // `x' refers to string ``abc'' here -}}}}}} -\end{lstlisting} - -A reference to a qualified (type- or term-) identifier $e.x$ refers to -the member of the type $T$ of $e$ which has the name $x$ in the same -namespace as the identifier. It is an error if $T$ is not a value type -(\sref{sec:value-types}). The type of $e.x$ is the member type of the -referenced entity in $T$. +(@) Assume the following two definitions of a objects named +`X` in packages `P` and `Q`. + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + package P { + object X { val x = 1; val y = 2 } + } + + package Q { + object X { val x = true; val y = "" } + } + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + The following program illustrates different kinds of bindings and + precedences between them. + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + package P { // `X' bound by package clause + import Console._ // `println' bound by wildcard import + object A { + println("L4: "+X) // `X' refers to `P.X' here + object B { + import Q._ // `X' bound by wildcard import + println("L7: "+X) // `X' refers to `Q.X' here + import X._ // `x' and `y' bound by wildcard import + println("L8: "+x) // `x' refers to `Q.X.x' here + object C { + val x = 3 // `x' bound by local definition + println("L12: "+x) // `x' refers to constant `3' here + { import Q.X._ // `x' and `y' bound by wildcard import + // println("L14: "+x) // reference to `x' is ambiguous here + import X.y // `y' bound by explicit import + println("L16: "+y) // `y' refers to `Q.X.y' here + { val x = "abc" // `x' bound by local definition + import P.X._ // `x' and `y' bound by wildcard import + // println("L19: "+y) // reference to `y' is ambiguous here + println("L20: "+x) // `x' refers to string ``abc'' here + }}}}}} + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +A reference to a qualified (type- or term-) identifier `e.x` refers to +the member of the type _T_ of _e_ which has the name _x_ in the same +namespace as the identifier. It is an error if _T_ is not a +[value type](#value-types). The type of `e.x` is the member type of the +referenced entity in _T_. diff --git a/build.sh b/build.sh index f3973b7d845c..64e1b9f7c299 100755 --- a/build.sh +++ b/build.sh @@ -2,8 +2,8 @@ find . -name "*.md" | \ cat 01-title.md \ 02-preface.md \ - 03-lexical-syntax.md > build/ScalaReference.md -# 04-identifiers-names-and-scopes.md \ + 03-lexical-syntax.md \ + 04-identifiers-names-and-scopes.md > build/ScalaReference.md # 05-types.md \ # 06-basic-declarations-and-definitions.md \ # 07-classes-and-objects.md \ diff --git a/resources/style.css b/resources/style.css index b0230de74880..9ef99126af01 100644 --- a/resources/style.css +++ b/resources/style.css @@ -18,6 +18,7 @@ header .date { pre { margin-left: 3em; + margin-right: 3em; padding: 1em; background-color: #EEE; border: 1px solid #333; @@ -27,7 +28,19 @@ code { background-color: #EEE; } +code > span { + font-weight: normal !important; +} + +code { + padding-left: 0.1em; + padding-right: 0.1em; +} + +/* examples */ ol[type="1"] { + background-color: #E5ECF9; + border: 1px dashed black; list-style-type: none; } From 7d50d8f26692fdf588d8dbca18095878f03a6abd Mon Sep 17 00:00:00 2001 From: Iain McGinniss Date: Fri, 19 Oct 2012 21:22:41 +0100 Subject: [PATCH 006/826] - Grouping of text for examples in Lexical Syntax chapter fixed - Style of examples elements changed to delineate grouped examples. --- 03-lexical-syntax.md | 210 +++++++++++++++++++++---------------------- resources/style.css | 8 +- 2 files changed, 112 insertions(+), 106 deletions(-) diff --git a/03-lexical-syntax.md b/03-lexical-syntax.md index c8d031bba64e..cbc09d2c9a24 100644 --- a/03-lexical-syntax.md +++ b/03-lexical-syntax.md @@ -94,17 +94,17 @@ equivalents ‘=>’ and ‘<-’, are also reserved. (@) Here are examples of identifiers: -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - x Object maxIndex p2p empty_? - + `yield` αρετη _y dot_product_* - __system _MAX_LEN_ -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + x Object maxIndex p2p empty_? + + `yield` αρετη _y dot_product_* + __system _MAX_LEN_ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ (@) Backquote-enclosed strings are a solution when one needs to -access Java identifiers that are reserved words in Scala. For -instance, the statement `Thread.yield()` is illegal, since -`yield` is a reserved word in Scala. However, here's a -work-around: `` Thread.`yield`() ``{.scala} + access Java identifiers that are reserved words in Scala. For + instance, the statement `Thread.yield()` is illegal, since + `yield` is a reserved word in Scala. However, here's a + work-around: `` Thread.`yield`() ``{.scala} Newline Characters @@ -202,95 +202,95 @@ A single new line token is accepted - after an annotation ([here](#user-defined-annotations)). (@) The following code contains four well-formed statements, each -on two lines. The newline tokens between the two lines are not -treated as statement separators. + on two lines. The newline tokens between the two lines are not + treated as statement separators. -~~~~~~~~~~~~~~~~~~~~~~ {.scala} -if (x > 0) - x = x - 1 + ~~~~~~~~~~~~~~~~~~~~~~ {.scala} + if (x > 0) + x = x - 1 -while (x > 0) - x = x / 2 + while (x > 0) + x = x / 2 -for (x <- 1 to 10) - println(x) + for (x <- 1 to 10) + println(x) -type - IntList = List[Int] -~~~~~~~~~~~~~~~~~~~~~~ + type + IntList = List[Int] + ~~~~~~~~~~~~~~~~~~~~~~ (@) The following code designates an anonymous class: -~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} -new Iterator[Int] -{ - private var x = 0 - def hasNext = true - def next = { x += 1; x } -} -~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + new Iterator[Int] + { + private var x = 0 + def hasNext = true + def next = { x += 1; x } + } + ~~~~~~~~~~~~~~~~~~~~~~~~~~~ -With an additional newline character, the same code is interpreted as -an object creation followed by a local block: + With an additional newline character, the same code is interpreted as + an object creation followed by a local block: -~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} -new Iterator[Int] + ~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + new Iterator[Int] -{ - private var x = 0 - def hasNext = true - def next = { x += 1; x } -} -~~~~~~~~~~~~~~~~~~~~~~~~~~~ + { + private var x = 0 + def hasNext = true + def next = { x += 1; x } + } + ~~~~~~~~~~~~~~~~~~~~~~~~~~~ (@) The following code designates a single expression: -~~~~~~~~~~~~ {.scala} - x < 0 || - x > 10 -~~~~~~~~~~~~ + ~~~~~~~~~~~~ {.scala} + x < 0 || + x > 10 + ~~~~~~~~~~~~ -With an additional newline character, the same code is interpreted as -two expressions: + With an additional newline character, the same code is interpreted as + two expressions: -~~~~~~~~~~~ {.scala} - x < 0 || + ~~~~~~~~~~~ {.scala} + x < 0 || - x > 10 -~~~~~~~~~~~ + x > 10 + ~~~~~~~~~~~ (@) The following code designates a single, curried function definition: -~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} -def func(x: Int) - (y: Int) = x + y -~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + def func(x: Int) + (y: Int) = x + y + ~~~~~~~~~~~~~~~~~~~~~~~~~ -With an additional newline character, the same code is interpreted as -an abstract function definition and a syntactically illegal statement: + With an additional newline character, the same code is interpreted as + an abstract function definition and a syntactically illegal statement: -~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} -def func(x: Int) + ~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + def func(x: Int) - (y: Int) = x + y -~~~~~~~~~~~~~~~~~~~~~~~~~ + (y: Int) = x + y + ~~~~~~~~~~~~~~~~~~~~~~~~~ (@) The following code designates an attributed definition: -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} -@serializable -protected class Data { ... } -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + @serializable + protected class Data { ... } + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -With an additional newline character, the same code is interpreted as -an attribute and a separate statement (which is syntactically -illegal). + With an additional newline character, the same code is interpreted as + an attribute and a separate statement (which is syntactically + illegal). -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} -@serializable + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + @serializable -protected class Data { ... } -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + protected class Data { ... } + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Literals @@ -350,9 +350,9 @@ is _pt_. The numeric ranges given by these types are: (@) Here are some integer literals: -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -0 21 0xFFFFFFFF 0777L -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + 0 21 0xFFFFFFFF 0777L + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ### Floating Point Literals @@ -379,15 +379,15 @@ whitespace character between the two tokens. (@) Here are some floating point literals: -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -0.0 1e30f 3.14159f 1.0e-100 .1 -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + 0.0 1e30f 3.14159f 1.0e-100 .1 + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ (@) The phrase `1.toString`{.scala} parses as three different tokens: -`1`{.scala}, `.`{.scala}, and `toString`{.scala}. On the -other hand, if a space is inserted after the period, the phrase -`1. toString`{.scala} parses as the floating point literal -`1.`{.scala} followed by the identifier `toString`{.scala}. + `1`{.scala}, `.`{.scala}, and `toString`{.scala}. On the + other hand, if a space is inserted after the period, the phrase + `1. toString`{.scala} parses as the floating point literal + `1.`{.scala} followed by the identifier `toString`{.scala}. ### Boolean Literals @@ -413,9 +413,9 @@ by an [escape sequence](#escape-sequences). (@) Here are some character literals: -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -'a' '\u0041' '\n' '\t' -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + 'a' '\u0041' '\n' '\t' + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Note that `'\u000A'` is _not_ a valid character literal because Unicode conversion is done before literal parsing and the Unicode @@ -440,10 +440,10 @@ class `String`{.scala}. (@) Here are some string literals: -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} -"Hello,\nWorld!" -"This string contains a \" character." -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + "Hello,\nWorld!" + "This string contains a \" character." + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #### Multi-Line String Literals @@ -462,19 +462,19 @@ of the escape sequences [here](#escape-sequences) are interpreted. (@) Here is a multi-line string literal: -~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} - """the present string - spans three - lines.""" -~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + """the present string + spans three + lines.""" + ~~~~~~~~~~~~~~~~~~~~~~~~ -This would produce the string: + This would produce the string: -~~~~~~~~~~~~~~~~~~~ -the present string - spans three - lines. -~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~ + the present string + spans three + lines. + ~~~~~~~~~~~~~~~~~~~ The Scala library contains a utility method `stripMargin` which can be used to strip leading whitespace from multi-line strings. @@ -596,11 +596,11 @@ as text. (@) The following value definition uses an XML literal with two embedded Scala expressions -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} -val b = - The Scala Language Specification - {scalaBook.version} - {scalaBook.authors.mkList("", ", ", "")} - -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + val b = + The Scala Language Specification + {scalaBook.version} + {scalaBook.authors.mkList("", ", ", "")} + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/resources/style.css b/resources/style.css index 9ef99126af01..cfe9053bb7cf 100644 --- a/resources/style.css +++ b/resources/style.css @@ -39,9 +39,15 @@ code { /* examples */ ol[type="1"] { + list-style-type: none; + margin-left: 0; +} + +ol[type="1"] li { + margin-top: 1em; + padding: 1em; background-color: #E5ECF9; border: 1px dashed black; - list-style-type: none; } ol[type="1"] li:before { From a805b0461be6cff86153cf82f1ec298bacba00a8 Mon Sep 17 00:00:00 2001 From: Iain McGinniss Date: Mon, 22 Oct 2012 22:37:17 +0100 Subject: [PATCH 007/826] interim commit of conversion of types chapter --- .DS_Store | Bin 0 -> 6148 bytes 05-types.md | 1061 +++++++++++++++++++++---------------------- README.md | 1 + build.sh | 9 +- resources/style.css | 4 - 5 files changed, 536 insertions(+), 539 deletions(-) create mode 100644 .DS_Store diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..fe0e33b7c27f03b9d5f45f3b7ed8e736038d3abe GIT binary patch literal 6148 zcmeHKOH0E*5T5Nr6IAF$^cXxBY4K4H9zv+#QD~tDE1H;M10g9%Y7aFUPyQQ!j=#s5 z-L15?Ud6`@%zl%3B+Qqvn*jjfjQu7+4FC*O!jg&03ZXdZl9aTkf+*xYd~cGDyfF5b za@p}S8K8Gp1rNp$KnU~i@6{WHL7FuhZ=zJLRM*xG(=;~wy&&@Ai4%__KfUY><4Gs* z2cDZ;Njr11aq75$~aFXYy zVVJcSV|#D^^t|g%AM(d1MW4X$Ov;wV89bvg*T;P)iNZL#LoZdBkiY;^h_TNEZpohe zQh#5kEBg7=@r)NnW`G%B239ek_flhHRgitm05kBf8KC{aLM5~{77FFofr}gg5a~Bk z3feSFP>rS0)>tUS2#Qdph^kcR5kshQ^jkX5)>tT1by=hH|Lp7ef3b+Km;q+sPca}W?M~almh{=W)Eu3)7U~Tu3FQ?EKT6P$ iM=|EoQM`*P1^pHoh_=Q;A$m~wM?liR3p4Po47>xfY=tTS literal 0 HcmV?d00001 diff --git a/05-types.md b/05-types.md index 104608da6ac9..cd28439e71b1 100644 --- a/05-types.md +++ b/05-types.md @@ -1,282 +1,287 @@ Types ===== - -\syntax\begin{lstlisting} - Type ::= FunctionArgTypes `=>' Type +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} + Type ::= FunctionArgTypes ‘=>’ Type | InfixType [ExistentialClause] FunctionArgTypes ::= InfixType - | `(' [ ParamType {`,' ParamType } ] `)' - ExistentialClause ::= `forSome' `{' ExistentialDcl {semi ExistentialDcl} `}' - ExistentialDcl ::= `type' TypeDcl - | `val' ValDcl + | ‘(’ [ ParamType {‘,’ ParamType } ] ‘)’ + ExistentialClause ::= ‘forSome’ ‘{’ ExistentialDcl {semi ExistentialDcl} ‘}’ + ExistentialDcl ::= ‘type’ TypeDcl + | ‘val’ ValDcl InfixType ::= CompoundType {id [nl] CompoundType} - CompoundType ::= AnnotType {`with' AnnotType} [Refinement] + CompoundType ::= AnnotType {‘with’ AnnotType} [Refinement] | Refinement AnnotType ::= SimpleType {Annotation} SimpleType ::= SimpleType TypeArgs - | SimpleType `#' id + | SimpleType ‘#’ id | StableId - | Path `.' `type' - | `(' Types ')' - TypeArgs ::= `[' Types `]' - Types ::= Type {`,' Type} -\end{lstlisting} + | Path ‘.’ ‘type’ + | ‘(’ Types ‘)’ + TypeArgs ::= ‘[’ Types ‘]’ + Types ::= Type {‘,’ Type} +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ We distinguish between first-order types and type constructors, which take type parameters and yield types. A subset of first-order types -called {\em value types} represents sets of (first-class) values. -Value types are either {\em concrete} or {\em abstract}. - -Every concrete value type can be represented as a {\em class type}, i.e.\ a -type designator (\sref{sec:type-desig}) that refers to a -a class or a trait\footnote{We assume that objects and packages also implicitly -define a class (of the same name as the object or package, but -inaccessible to user programs).} (\sref{sec:class-defs}), or as a {\em -compound type} (\sref{sec:compound-types}) representing an -intersection of types, possibly with a refinement -(\sref{sec:refinements}) that further constrains the types of its -members. -\comment{A shorthand exists for denoting function types (\sref{sec:function-types}). } -Abstract value types are introduced by type parameters (\sref{sec:type-params}) -and abstract type bindings (\sref{sec:typedcl}). Parentheses in types can be used for -grouping. - -%@M -Non-value types capture properties of identifiers that are not values -(\sref{sec:synthetic-types}). For example, a type constructor (\sref{sec:higherkinded-types}) does not directly specify a type of values. However, when a type constructor is applied to the correct type arguments, it yields a first-order type, which may be a value type. - -Non-value types are expressed indirectly in Scala. E.g., a method type is described by writing down a method signature, which in itself is not a real type, although it gives rise to a corresponding method type (\sref{sec:method-types}). Type constructors are another example, as one can write \lstinline@type Swap[m[_, _], a,b] = m[b, a]@, but there is no syntax to write the corresponding anonymous type function directly. - -\section{Paths}\label{sec:paths}\label{sec:stable-ids} - -\syntax\begin{lstlisting} - Path ::= StableId - | [id `.'] this - StableId ::= id - | Path `.' id - | [id '.'] `super' [ClassQualifier] `.' id - ClassQualifier ::= `[' id `]' -\end{lstlisting} +called _value types_ represents sets of (first-class) values. +Value types are either _concrete_ or _abstract_. + +Every concrete value type can be represented as a _class type_, i.e. a +[type designator](#type-designators) that refers to a +a [class or a trait](#class-definitions) [^1], or as a +[compound type](#compound-types) representing an +intersection of types, possibly with a [refinement](#compound-types) +that further constrains the types of its members. + +Abstract value types are introduced by [type parameters](#type-parameters) +and [abstract type bindings](#type-declarations-and-type-aliases). +Parentheses in types can be used for grouping. + +[^1]: We assume that objects and packages also implicitly + define a class (of the same name as the object or package, but + inaccessible to user programs). + +Non-value types capture properties of identifiers that +[are not values](#non-value-types). For example, a +[type constructor](#type-constructors) does not directly specify a type of +values. However, when a type constructor is applied to the correct type +arguments, it yields a first-order type, which may be a value type. + +Non-value types are expressed indirectly in Scala. E.g., a method type is +described by writing down a method signature, which in itself is not a real +type, although it gives rise to a corresponding [method type](#method-types). +Type constructors are another example, as one can write +`type Swap[m[_, _], a,b] = m[b, a]`{.scala}, but there is no syntax to write +the corresponding anonymous type function directly. + + +Paths +----- + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +Path ::= StableId + | [id ‘.’] this +StableId ::= id + | Path ‘.’ id + | [id ‘.’] ‘super’ [ClassQualifier] ‘.’ id +ClassQualifier ::= ‘[’ id ‘]’ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Paths are not types themselves, but they can be a part of named types and in that function form a central role in Scala's type system. A path is one of the following. -\begin{itemize} -\item -The empty path $\epsilon$ (which cannot be written explicitly in user programs). -\item -\lstinline@$C$.this@, where $C$ references a class. -The path \code{this} is taken as a shorthand for \lstinline@$C$.this@ where -$C$ is the name of the class directly enclosing the reference. -\item -\lstinline@$p$.$x$@ where $p$ is a path and $x$ is a stable member of $p$. -{\em Stable members} are packages or members introduced by object definitions or -by value definitions of non-volatile types -(\sref{sec:volatile-types}). -\item -\lstinline@$C$.super.$x$@ or \lstinline@$C$.super[$M\,$].$x$@ -where $C$ references a class and $x$ references a -stable member of the super class or designated parent class $M$ of $C$. -The prefix \code{super} is taken as a shorthand for \lstinline@$C$.super@ where -$C$ is the name of the class directly enclosing the reference. -\end{itemize} -A {\em stable identifier} is a path which ends in an identifier. +- The empty path ε (which cannot be written explicitly in user programs). +- `C.this`, where _C_ references a class. + The path `this` is taken as a shorthand for `C.this` where + _C_ is the name of the class directly enclosing the reference. +- `p.x` where _p_ is a path and _x_ is a stable member of _p_. + _Stable members_ are packages or members introduced by object definitions or + by value definitions of [non-volatile types](#volatile-types). +- `C.super.x` or `C.super[M].x` + where _C_ references a class and _x_ references a + stable member of the super class or designated parent class _M_ of _C_. + The prefix `super`{.scala} is taken as a shorthand for `C.super` where + _C_ is the name of the class directly enclosing the reference. + -\section{Value Types}\label{sec:value-types} +A _stable identifier_ is a path which ends in an identifier. + +Value Types +----------- Every value in Scala has a type which is of one of the following forms. -\subsection{Singleton Types} -\label{sec:singleton-types} -\label{sec:type-stability} +### Singleton Types -\syntax\begin{lstlisting} - SimpleType ::= Path `.' type -\end{lstlisting} +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +SimpleType ::= Path ‘.’ type +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -A singleton type is of the form \lstinline@$p$.type@, where $p$ is a -path pointing to a value expected to conform (\sref{sec:expr-typing}) -to \lstinline@scala.AnyRef@. The type denotes the set of values -consisting of \code{null} and the value denoted by $p$. +A singleton type is of the form `p.type`{.scala}, where _p_ is a +path pointing to a value expected to [conform](#expression-typing) +to `scala.AnyRef`{.scala}. The type denotes the set of values +consisting of `null`{.scala} and the value denoted by _p_. -A {\em stable type} is either a singleton type or a type which is -declared to be a subtype of trait \lstinline@scala.Singleton@. +A _stable type_ is either a singleton type or a type which is +declared to be a subtype of trait `scala.Singleton`{.scala}. -\subsection{Type Projection} -\label{sec:type-project} +### Type Projection -\syntax\begin{lstlisting} - SimpleType ::= SimpleType `#' id -\end{lstlisting} +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +SimpleType ::= SimpleType ‘#’ id +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -A type projection \lstinline@$T$#$x$@ references the type member named -$x$ of type $T$. -% The following is no longer necessary: -%If $x$ references an abstract type member, then $T$ must be a stable type (\sref{sec:singleton-types}). +A type projection `T#x`{.scala} references the type member named +_x_ of type _T_. -\subsection{Type Designators} -\label{sec:type-desig} + -\syntax\begin{lstlisting} - SimpleType ::= StableId -\end{lstlisting} +### Type Designators + +~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} +SimpleType ::= StableId +~~~~~~~~~~~~~~~~~~~~~~~~~~ A type designator refers to a named value type. It can be simple or qualified. All such type designators are shorthands for type projections. -Specifically, the unqualified type name $t$ where $t$ is bound in some -class, object, or package $C$ is taken as a shorthand for -\lstinline@$C$.this.type#$t$@. If $t$ is -not bound in a class, object, or package, then $t$ is taken as a -shorthand for \lstinline@$\epsilon$.type#$t$@. - -A qualified type designator has the form \lstinline@$p$.$t$@ where $p$ is -a path (\sref{sec:paths}) and $t$ is a type name. Such a type designator is -equivalent to the type projection \lstinline@$p$.type#$t$@. - -\example -Some type designators and their expansions are listed below. We assume -a local type parameter $t$, a value \code{maintable} -with a type member \code{Node} and the standard class \lstinline@scala.Int@, -\begin{lstlisting} - t $\epsilon$.type#t - Int scala.type#Int - scala.Int scala.type#Int - data.maintable.Node data.maintable.type#Node -\end{lstlisting} - -\subsection{Parameterized Types} -\label{sec:param-types} - -\syntax\begin{lstlisting} - SimpleType ::= SimpleType TypeArgs - TypeArgs ::= `[' Types `]' -\end{lstlisting} - -A parameterized type $T[U_1 \commadots U_n]$ consists of a type -designator $T$ and type parameters $U_1 \commadots U_n$ where $n \geq -1$. $T$ must refer to a type constructor which takes $n$ type -parameters $a_1 \commadots a_n$. - -Say the type parameters have lower bounds $L_1 \commadots L_n$ and -upper bounds $U_1 \commadots U_n$. The parameterized type is -well-formed if each actual type parameter {\em conforms to its -bounds}, i.e.\ $\sigma L_i <: T_i <: \sigma U_i$ where $\sigma$ is the -substitution $[a_1 := T_1 \commadots a_n := T_n]$. - -\example\label{ex:param-types} -Given the partial type definitions: - -\begin{lstlisting} - class TreeMap[A <: Comparable[A], B] { $\ldots$ } - class List[A] { $\ldots$ } - class I extends Comparable[I] { $\ldots$ } - - class F[M[_], X] { $\ldots$ } - class S[K <: String] { $\ldots$ } - class G[M[ Z <: I ], I] { $\ldots$ } -\end{lstlisting} - -the following parameterized types are well formed: - -\begin{lstlisting} - TreeMap[I, String] - List[I] - List[List[Boolean]] - - F[List, Int] - G[S, String] -\end{lstlisting} - -\example Given the type definitions of \ref{ex:param-types}, -the following types are ill-formed: - -\begin{lstlisting} - TreeMap[I] // illegal: wrong number of parameters - TreeMap[List[I], Int] // illegal: type parameter not within bound - - F[Int, Boolean] // illegal: Int is not a type constructor - F[TreeMap, Int] // illegal: TreeMap takes two parameters, - // F expects a constructor taking one - G[S, Int] // illegal: S constrains its parameter to - // conform to String, - // G expects type constructor with a parameter - // that conforms to Int -\end{lstlisting} - -\subsection{Tuple Types}\label{sec:tuple-types} - -\syntax\begin{lstlisting} - SimpleType ::= `(' Types ')' -\end{lstlisting} - -A tuple type \lstinline@($T_1 \commadots T_n$)@ is an alias for the -class ~\lstinline@scala.Tuple$n$[$T_1 \commadots T_n$]@, where $n \geq -2$. +Specifically, the unqualified type name _t_ where _t_ is bound in some +class, object, or package _C_ is taken as a shorthand for +`C.this.type#t`{.scala}. If _t_ is +not bound in a class, object, or package, then _t_ is taken as a +shorthand for `ε.type#t`. + +A qualified type designator has the form `p.t` where `p` is +a [path](#paths) and _t_ is a type name. Such a type designator is +equivalent to the type projection `p.type#t`{.scala}. + +(@) Some type designators and their expansions are listed below. We assume + a local type parameter _t_, a value `maintable` + with a type member `Node` and the standard class `scala.Int`, + + -------------------- -------------------------- + t $\epsilon$.type#t + Int scala.type#Int + scala.Int scala.type#Int + data.maintable.Node data.maintable.type#Node + -------------------- -------------------------- + + +### Parameterized Types + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +SimpleType ::= SimpleType TypeArgs +TypeArgs ::= ‘[’ Types ‘]’ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +A parameterized type T[ U~1~ , … , U~n~ ] consists of a type +designator _T_ and type parameters _U~1~ , … , U~n~_ where +_n ≥ 1_. _T_ must refer to a type constructor which takes _n_ type +parameters _a~1~ , … , s a~n~_. + +Say the type parameters have lower bounds _L~1~ , … , L~n~_ and +upper bounds _U~1~ … U~n~_. The parameterized type is +well-formed if each actual type parameter +_conforms to its bounds_, i.e. _σ L~i~ <: T~i~ <: σ U~i~_ where σ is the +substitution [ _a~1~_ := _T~1~_ , … , _a~n~_ := _T~n~_ ]. + +(@param-types) Given the partial type definitions: + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + class TreeMap[A <: Comparable[A], B] { … } + class List[A] { … } + class I extends Comparable[I] { … } + + class F[M[_], X] { … } + class S[K <: String] { … } + class G[M[ Z <: I ], I] { … } + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + the following parameterized types are well formed: + + ~~~~~~~~~~~~~~~~~~~~~~ {.scala} + TreeMap[I, String] + List[I] + List[List[Boolean]] + + F[List, Int] + G[S, String] + ~~~~~~~~~~~~~~~~~~~~~~ + +(@) Given the type definitions of (@param-types), + the following types are ill-formed: + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + TreeMap[I] // illegal: wrong number of parameters + TreeMap[List[I], Int] // illegal: type parameter not within bound + + F[Int, Boolean] // illegal: Int is not a type constructor + F[TreeMap, Int] // illegal: TreeMap takes two parameters, + // F expects a constructor taking one + G[S, Int] // illegal: S constrains its parameter to + // conform to String, + // G expects type constructor with a parameter + // that conforms to Int + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +### Tuple Types + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +SimpleType ::= ‘(’ Types ‘)’ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +A tuple type (T~1~ , … , T~n~) is an alias for the +class `scala.Tuple`~n~`[`T~1~`, … , `T~n~`]`, where _n ≥ 2_. Tuple classes are case classes whose fields can be accessed using -selectors ~\code{_1}, ..., \lstinline@_$n$@. Their functionality is -abstracted in a corresponding \code{Product} trait. The $n$-ary tuple +selectors `_1` , … , `_n`. Their functionality is +abstracted in a corresponding `Product` trait. The _n_-ary tuple class and product trait are defined at least as follows in the standard Scala library (they might also add other methods and implement other traits). -\begin{lstlisting} -case class Tuple$n$[+T1, ..., +T$n$](_1: T1, ..., _$n$: T$n$) -extends Product$n$[T1, ..., T$n$] {} +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} +case class Tuple_n[+T1, … , +Tn](_1: T1, … , _n: Tn) +extends Product_n[T1, … , Tn] {} -trait Product$n$[+T1, +T2, +T$n$] { - override def arity = $n$ +trait Product_n[+T1, … , +Tn] { + override def arity = n def _1: T1 - ... - def _$n$:T$n$ + … + def _n: Tn } -\end{lstlisting} +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -\subsection{Annotated Types} +### Annotated Types -\syntax\begin{lstlisting} - AnnotType ::= SimpleType {Annotation} -\end{lstlisting} +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +AnnotType ::= SimpleType {Annotation} +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -An annotated type ~$T$\lstinline@ $a_1 \ldots a_n$@ -attaches annotations $a_1 \commadots a_n$ to the type $T$ -(\sref{sec:annotations}). +An annotated type _T a~1~ , … , a~n~_ +attaches [annotations](#user-defined-annotations) +_a~1~ , … , a~n~_ to the type _T_. -\example The following type adds the \code{@suspendable}@ annotation to the type -\code{String}: -\begin{lstlisting} - String @suspendable -\end{lstlisting} +(@) The following type adds the `@suspendable`{.scala} annotation to the type + `String`{.scala}: -\subsection{Compound Types} -\label{sec:compound-types} -\label{sec:refinements} - -\syntax\begin{lstlisting} - CompoundType ::= AnnotType {`with' AnnotType} [Refinement] - | Refinement - Refinement ::= [nl] `{' RefineStat {semi RefineStat} `}' - RefineStat ::= Dcl - | `type' TypeDef - | -\end{lstlisting} + ~~~~~~~~~~~~~~~~~~~~ {.scala} + String @suspendable + ~~~~~~~~~~~~~~~~~~~~ -A compound type ~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@~ -represents objects with members as given in the component types $T_1 -\commadots T_n$ and the refinement \lstinline@{$R\,$}@. A refinement -\lstinline@{$R\,$}@ contains declarations and type definitions. + +### Compound Types + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +CompoundType ::= AnnotType {‘with’ AnnotType} [Refinement] + | Refinement +Refinement ::= [nl] ‘{’ RefineStat {semi RefineStat} ‘}’ +RefineStat ::= Dcl + | ‘type’ TypeDef + | +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +A compound type `T1 with … with Tn { R }` +represents objects with members as given in the component types +_T1 , … , Tn_ and the refinement `{ R }`. A refinement +`{ R }` contains declarations and type definitions. If a declaration or definition overrides a declaration or definition in -one of the component types $T_1 \commadots T_n$, the usual rules for -overriding (\sref{sec:overriding}) apply; otherwise the declaration -or definition is said to be ``structural''\footnote{A reference to a -structurally defined member (method call or access to a value or -variable) may generate binary code that is significantly slower than -an equivalent code to a non-structural member.}. +one of the component types _T1 , … , T_n_, the usual rules for +[overriding](#overriding) apply; otherwise the declaration +or definition is said to be “structural” [^2]. + +[^2]: A reference to a structurally defined member (method call or access +to a value or variable) may generate binary code that is significantly +slower than an equivalent code to a non-structural member. Within a method declaration in a structural refinement, the type of any value parameter may only refer to type parameters or abstract @@ -286,155 +291,163 @@ definition within the refinement. This restriction does not apply to the function's result type. If no refinement is given, the empty refinement is implicitly added, -i.e.\ ~\lstinline@$T_1$ with $\ldots$ with $T_n$@~ is a shorthand for -~\lstinline@$T_1$ with $\ldots$ with $T_n$ {}@. +i.e.\ `T1 with … with Tn`{.scala} is a shorthand for +`T1 with … with Tn {}`{.scala}. A compound type may also consist of just a refinement -~\lstinline@{$R\,$}@ with no preceding component types. Such a type is -equivalent to ~\lstinline@AnyRef{$R\,$}@. - -\example The following example shows how to declare and use a function which parameter's type contains a refinement with structural declarations. -\begin{lstlisting}[escapechar=\%] - case class Bird (val name: String) extends Object { - def fly(height: Int) = ... - ... - } - case class Plane (val callsign: String) extends Object { - def fly(height: Int) = ... - ... - } - def takeoff( - runway: Int, - r: { val callsign: String; def fly(height: Int) }) = { - tower.print(r.callsign + " requests take-off on runway " + runway) - tower.read(r.callsign + " is clear f%%or take-off") - r.fly(1000) - } - val bird = new Bird("Polly the parrot"){ val callsign = name } - val a380 = new Plane("TZ-987") - takeoff(42, bird) - takeoff(89, a380) -\end{lstlisting} -Although ~\lstinline@Bird@ and ~\lstinline@Plane@ do not share any parent class other than ~\lstinline@Object@, the parameter ~\lstinline@r@ of function ~\lstinline@takeoff@ is defined using a refinement with structural declarations to accept any object that declares a value ~\lstinline@callsign@ and a ~\lstinline@fly@ function. +`{ R }` with no preceding component types. Such a type is +equivalent to `AnyRef{ R }`{.scala}. + +(@) The following example shows how to declare and use a function which + parameter's type contains a refinement with structural declarations. + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + case class Bird (val name: String) extends Object { + def fly(height: Int) = … + … + } + case class Plane (val callsign: String) extends Object { + def fly(height: Int) = … + … + } + def takeoff( + runway: Int, + r: { val callsign: String; def fly(height: Int) }) = { + tower.print(r.callsign + " requests take-off on runway " + runway) + tower.read(r.callsign + " is clear for take-off") + r.fly(1000) + } + val bird = new Bird("Polly the parrot"){ val callsign = name } + val a380 = new Plane("TZ-987") + takeoff(42, bird) + takeoff(89, a380) + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + Although `Bird` and `Plane` do not share any parent class other than + `Object`, the parameter _r_ of function `takeoff` is defined using a + refinement with structural declarations to accept any object that declares + a value `callsign` and a `fly` function. -\subsection{Infix Types}\label{sec:infix-types} +### Infix Types -\syntax\begin{lstlisting} - InfixType ::= CompoundType {id [nl] CompoundType} -\end{lstlisting} -An infix type ~\lstinline@$T_1\;\op\;T_2$@~ consists of an infix -operator $\op$ which gets applied to two type operands $T_1$ and -$T_2$. The type is equivalent to the type application $\op[T_1, -T_2]$. The infix operator $\op$ may be an arbitrary identifier, -except for \code{*}, which is reserved as a postfix modifier -denoting a repeated parameter type (\sref{sec:repeated-params}). +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +InfixType ::= CompoundType {id [nl] CompoundType} +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +An infix type _T~1~ op T~2~_ consists of an infix +operator _op_ which gets applied to two type operands _T~1~_ and +_T~2~_. The type is equivalent to the type application +`op[T₁, T₂]`. The infix operator _op_ may be an arbitrary identifier, +except for `*`, which is reserved as a postfix modifier +denoting a [repeated parameter type](#repeated-parameters). All type infix operators have the same precedence; parentheses have to -be used for grouping. The associativity (\sref{sec:infix-operations}) +be used for grouping. The [associativity](#prefix-infix-and-postfix-operations) of a type operator is determined as for term operators: type operators -ending in a colon `\lstinline@:@' are right-associative; all other +ending in a colon ‘:’ are right-associative; all other operators are left-associative. -In a sequence of consecutive type infix operations $t_0; \op_1; t_1; -\op_2 \ldots \op_n; t_n$, all operators $\op_1 \commadots \op_n$ must have the same +In a sequence of consecutive type infix operations +$t_0 \, op \, t_1 \, op_2 \, … \, op_n \, t_n$, +all operators $\op_1 , … , \op_n$ must have the same associativity. If they are all left-associative, the sequence is -interpreted as $(\ldots(t_0;\op_1;t_1);\op_2\ldots);\op_n;t_n$, -otherwise it is interpreted as $t_0;\op_1;(t_1;\op_2;(\ldots\op_n;t_n)\ldots)$. +interpreted as `(… (t_0 op_1 t_1) op_2 …) op_n t_n`, +otherwise it is interpreted as $t_0 op_1 (t_1 op_2 ( … op_n t_n) …)$. -\subsection{Function Types} -\label{sec:function-types} +### Function Types -\syntax\begin{lstlisting} - Type ::= FunctionArgs `=>' Type - FunctionArgs ::= InfixType - | `(' [ ParamType {`,' ParamType } ] `)' -\end{lstlisting} -The type ~\lstinline@($T_1 \commadots T_n$) => $U$@~ represents the set of function -values that take arguments of types $T_1 \commadots T_n$ and yield +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} +Type ::= FunctionArgs ‘=>’ Type +FunctionArgs ::= InfixType + | ‘(’ [ ParamType {‘,’ ParamType } ] ‘)’ +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The type $(T_1 , \ldots , T_n) \Rightarrow U$ represents the set of function +values that take arguments of types $T1 , \ldots , Tn$ and yield results of type $U$. In the case of exactly one argument type -~\lstinline@$T$ => $U$@~ is a shorthand for ~\lstinline@($T\,$) => $U$@. -An argument type of the form~\lstinline@=> T@ -represents a call-by-name parameter (\sref{sec:by-name-params}) of type $T$. +$T \Rightarrow U$ is a shorthand for $(T) \Rightarrow U$. +An argument type of the form $\Rightarrow T$ +represents a [call-by-name parameter](#by-name-parameters) of type $T$. Function types associate to the right, e.g. -~\lstinline@$S$ => $T$ => $U$@~ is the same as -~\lstinline@$S$ => ($T$ => $U$)@. +`S => T => U` is the same as `S => (T => U)`. -Function types are shorthands for class types that define \code{apply} +Function types are shorthands for class types that define `apply` functions. Specifically, the $n$-ary function type -~\lstinline@($T_1 \commadots T_n$) => U@~ is a shorthand for the class type -\lstinline@Function$n$[$T_1 \commadots T_n$,$U\,$]@. Such class +`(T1 , … , Tn) => U` is a shorthand for the class type +`Function_n[T1 , … , Tn, U]`. Such class types are defined in the Scala library for $n$ between 0 and 9 as follows. -\begin{lstlisting} + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} package scala -trait Function$n$[-$T_1 \commadots$ -$T_n$, +$R$] { - def apply($x_1$: $T_1 \commadots x_n$: $T_n$): $R$ +trait Function_n[-T1 , … , -Tn, +R] { + def apply(x1: T1 , … , xn: Tn): R override def toString = "" } -\end{lstlisting} -Hence, function types are covariant (\sref{sec:variances}) in their +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Hence, function types are [covariant](#variance-annotations) in their result type and contravariant in their argument types. +### Existential Types -\subsection{Existential Types} -\label{sec:existential-types} +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +Type ::= InfixType ExistentialClauses +ExistentialClauses ::= ‘forSome’ ‘{’ ExistentialDcl + {semi ExistentialDcl} ‘}’ +ExistentialDcl ::= ‘type’ TypeDcl + | ‘val’ ValDcl +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -\syntax\begin{lstlisting} - Type ::= InfixType ExistentialClauses - ExistentialClauses ::= `forSome' `{' ExistentialDcl - {semi ExistentialDcl} `}' - ExistentialDcl ::= `type' TypeDcl - | `val' ValDcl -\end{lstlisting} -An existential type has the form ~\lstinline@$T$ forSome {$\,Q\,$}@~ -where $Q$ is a sequence of type declarations \sref{sec:typedcl}. -Let $t_1[\tps_1] >: L_1 <: U_1 \commadots t_n[\tps_n] >: L_n <: U_n$ +An existential type has the form `T forSome { Q }` +where _Q_ is a sequence of +[type declarations](#type-declarations-and-type-aliases). + +Let $t_1[\mathit{tps}_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}_n] >: L_n <: U_n$ be the types declared in $Q$ (any of the -type parameter sections \lstinline@[$\tps_i$]@ might be missing). -The scope of each type $t_i$ includes the type $T$ and the existential clause $Q$. -The type variables $t_i$ are said to be {\em bound} in the type ~\lstinline@$T$ forSome {$\,Q\,$}@. -Type variables which occur in a type $T$ but which are not bound in $T$ are said -to be {\em free} in $T$. +type parameter sections [ _tps~i~_ ] might be missing). +The scope of each type _t~i~_ includes the type _T_ and the existential clause _Q_. +The type variables _t~i~_ are said to be _bound_ in the type `T forSome { Q }`. +Type variables which occur in a type _T_ but which are not bound in _T_ are said +to be _free_ in _T_. -A {\em type instance} of ~\lstinline@$T$ forSome {$\,Q\,$}@ +%%% iainmcgin: to here + +A _type instance_ of ~\lstinline@$T$ forSome {$\,Q\,$}@ is a type $\sigma T$ where $\sigma$ is a substitution over $t_1 \commadots t_n$ such that, for each $i$, $\sigma L_i \conforms \sigma t_i \conforms \sigma U_i$. The set of values denoted by the existential type ~\lstinline@$T$ forSome {$\,Q\,$}@~ is the union of the set of values of all its type instances. -A {\em skolemization} of ~\lstinline@$T$ forSome {$\,Q\,$}@~ is +A _skolemization_ of ~\lstinline@$T$ forSome {$\,Q\,$}@~ is a type instance $\sigma T$, where $\sigma$ is the substitution $[t'_1/t_1 \commadots t'_n/t_n]$ and each $t'_i$ is a fresh abstract type with lower bound $\sigma L_i$ and upper bound $\sigma U_i$. -\subsubsection*{Simplification Rules}\label{sec:ex-simpl} +#### Simplification Rules Existential types obey the following four equivalences: -\begin{enumerate} -\item -Multiple for-clauses in an existential type can be merged. E.g., + +#. Multiple for-clauses in an existential type can be merged. E.g., ~\lstinline@$T$ forSome {$\,Q\,$} forSome {$\,Q'\,$}@~ is equivalent to ~\lstinline@$T$ forSome {$\,Q\,$;$\,Q'\,$}@. -\item -Unused quantifications can be dropped. E.g., +#. Unused quantifications can be dropped. E.g., ~\lstinline@$T$ forSome {$\,Q\,$;$\,Q'\,$}@~ where none of the types defined in $Q'$ are referred to by $T$ or $Q$, is equivalent to ~\lstinline@$T$ forSome {$\,Q\,$}@. -\item -An empty quantification can be dropped. E.g., +#. An empty quantification can be dropped. E.g., ~\lstinline@$T$ forSome { }@~ is equivalent to ~\lstinline@$T$@. -\item -An existential type ~\lstinline@$T$ forSome {$\,Q\,$}@~ where $Q$ contains +#. An existential type ~\lstinline@$T$ forSome {$\,Q\,$}@~ where $Q$ contains a clause ~\lstinline@type $t[\tps] >: L <: U$@ is equivalent to the type ~\lstinline@$T'$ forSome {$\,Q\,$}@~ where $T'$ results from $T$ by replacing every covariant occurrence (\sref{sec:variances}) of $t$ in $T$ by $U$ and by replacing every contravariant occurrence of $t$ in $T$ by $L$. -\end{enumerate} -\subsubsection*{Existential Quantification over Values}\label{sec:val-existential-types} + +#### Existential Quantification over Values As a syntactic convenience, the bindings clause in an existential type may also contain @@ -445,14 +458,14 @@ is treated as a shorthand for the type type name and $T'$ results from $T$ by replacing every occurrence of \lstinline@$x$.type@ with $t$. -\subsubsection*{Placeholder Syntax for Existential Types}\label{sec:impl-existential-types} +#### Placeholder Syntax for Existential Types -\syntax\begin{lstlisting} - WildcardType ::= `_' TypeBounds -\end{lstlisting} +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.grammar} +WildcardType ::= ‘_’ TypeBounds +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Scala supports a placeholder syntax for existential types. -A {\em wildcard type} is of the form ~\lstinline@_$\;$>:$\,L\,$<:$\,U$@. Both bound +A _wildcard type_ is of the form ~\lstinline@_$\;$>:$\,L\,$<:$\,U$@. Both bound clauses may be omitted. If a lower bound clause \lstinline@>:$\,L$@ is missing, \lstinline@>:$\,$scala.Nothing@~ is assumed. If an upper bound clause ~\lstinline@<:$\,U$@ is missing, @@ -462,10 +475,12 @@ existentially quantified type variable, where the existential quantification is A wildcard type must appear as type argument of a parameterized type. Let $T = p.c[\targs,T,\targs']$ be a parameterized type where $\targs, \targs'$ may be empty and $T$ is a wildcard type ~\lstinline@_$\;$>:$\,L\,$<:$\,U$@. Then $T$ is equivalent to the existential -type -\begin{lstlisting} - $p.c[\targs,t,\targs']$ forSome { type $t$ >: $L$ <: $U$ } -\end{lstlisting} +type + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +$p.c[\targs,t,\targs']$ forSome { type $t$ >: $L$ <: $U$ } +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + where $t$ is some fresh type variable. Wildcard types may also appear as parts of infix types (\sref{sec:infix-types}), function types (\sref{sec:function-types}), @@ -473,52 +488,65 @@ or tuple types (\sref{sec:tuple-types}). Their expansion is then the expansion in the equivalent parameterized type. -\example Assume the class definitions -\begin{lstlisting} -class Ref[T] -abstract class Outer { type T } . -\end{lstlisting} -Here are some examples of existential types: -\begin{lstlisting} -Ref[T] forSome { type T <: java.lang.Number } -Ref[x.T] forSome { val x: Outer } -Ref[x_type # T] forSome { type x_type <: Outer with Singleton } -\end{lstlisting} -The last two types in this list are equivalent. -An alternative formulation of the first type above using wildcard syntax is: -\begin{lstlisting} -Ref[_ <: java.lang.Number] -\end{lstlisting} - -\example The type \lstinline@List[List[_]]@ is equivalent to the existential type -\begin{lstlisting} -List[List[t] forSome { type t }] . -\end{lstlisting} - -\example Assume a covariant type -\begin{lstlisting} -class List[+T] -\end{lstlisting} -The type -\begin{lstlisting} -List[T] forSome { type T <: java.lang.Number } -\end{lstlisting} -is equivalent (by simplification rule 4 above) to -\begin{lstlisting} -List[java.lang.Number] forSome { type T <: java.lang.Number } -\end{lstlisting} -which is in turn equivalent (by simplification rules 2 and 3 above) to -\lstinline@List[java.lang.Number]@. - -\section{Non-Value Types} -\label{sec:synthetic-types} +(@) Assume the class definitions + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + class Ref[T] + abstract class Outer { type T } . + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + Here are some examples of existential types: + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + Ref[T] forSome { type T <: java.lang.Number } + Ref[x.T] forSome { val x: Outer } + Ref[x_type # T] forSome { type x_type <: Outer with Singleton } + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + The last two types in this list are equivalent. + An alternative formulation of the first type above using wildcard syntax is: + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + Ref[_ <: java.lang.Number] + ~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +(@) The type `List[List[_]]` is equivalent to the existential type + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + List[List[t] forSome { type t }] . + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +(@) Assume a covariant type + + ~~~~~~~~~~~~~~~ {.scala} + class List[+T] + ~~~~~~~~~~~~~~~ + + The type + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + List[T] forSome { type T <: java.lang.Number } + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + is equivalent (by simplification rule 4 above) to + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + List[java.lang.Number] forSome { type T <: java.lang.Number } + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + which is in turn equivalent (by simplification rules 2 and 3 above) to + `List[java.lang.Number]`. + + +Non-Value Types +--------------- The types explained in the following do not denote sets of values, nor do they appear explicitly in programs. They are introduced in this report as the internal types of defined identifiers. -\subsection{Method Types} -\label{sec:method-types} + +### Method Types A method type is denoted internally as $(\Ps)U$, where $(\Ps)$ is a sequence of parameter names and types $(p_1:T_1 \commadots p_n:T_n)$ @@ -539,21 +567,24 @@ Method types do not exist as types of values. If a method name is used as a value, its type is implicitly converted to a corresponding function type (\sref{sec:impl-conv}). -\example The declarations -\begin{lstlisting} -def a: Int -def b (x: Int): Boolean -def c (x: Int) (y: String, z: String): String -\end{lstlisting} -produce the typings -\begin{lstlisting} -a: => Int -b: (Int) Boolean -c: (Int) (String, String) String -\end{lstlisting} +(@) The declarations + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + def a: Int + def b (x: Int): Boolean + def c (x: Int) (y: String, z: String): String + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + produce the typings + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + a: => Int + b: (Int) Boolean + c: (Int) (String, String) String + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +### Polymorphic Method Types -\subsection{Polymorphic Method Types} -\label{sec:poly-types} A polymorphic method type is denoted internally as ~\lstinline@[$\tps\,$]$T$@~ where \lstinline@[$\tps\,$]@ is a type parameter section @@ -565,123 +596,85 @@ conform (\sref{sec:param-types}) to the lower bounds ~\lstinline@$L_1 \commadots L_n$@~ and the upper bounds ~\lstinline@$U_1 \commadots U_n$@~ and that yield results of type $T$. -\example The declarations -\begin{lstlisting} -def empty[A]: List[A] -def union[A <: Comparable[A]] (x: Set[A], xs: Set[A]): Set[A] -\end{lstlisting} -produce the typings -\begin{lstlisting} -empty : [A >: Nothing <: Any] List[A] -union : [A >: Nothing <: Comparable[A]] (x: Set[A], xs: Set[A]) Set[A] . -\end{lstlisting} +(@) The declarations -\subsection{Type Constructors} %@M -\label{sec:higherkinded-types} -A type constructor is represented internally much like a polymorphic method type. -~\lstinline@[$\pm$ $a_1$ >: $L_1$ <: $U_1 \commadots \pm a_n$ >: $L_n$ <: $U_n$] $T$@~ represents a type that is expected by a type constructor parameter (\sref{sec:type-params}) or an abstract type constructor binding (\sref{sec:typedcl}) with the corresponding type parameter clause. + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + def empty[A]: List[A] + def union[A <: Comparable[A]] (x: Set[A], xs: Set[A]): Set[A] + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -\example Consider this fragment of the \lstinline@Iterable[+X]@ class: -\begin{lstlisting} -trait Iterable[+X] { - def flatMap[newType[+X] <: Iterable[X], S](f: X => newType[S]): newType[S] -} -\end{lstlisting} + produce the typings -Conceptually, the type constructor \lstinline@Iterable@ is a name for the anonymous type \lstinline@[+X] Iterable[X]@, which may be passed to the \lstinline@newType@ type constructor parameter in \lstinline@flatMap@. + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + empty : [A >: Nothing <: Any] List[A] + union : [A >: Nothing <: Comparable[A]] (x: Set[A], xs: Set[A]) Set[A] . + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -\comment{ -\subsection{Overloaded Types} -\label{sec:overloaded-types} +### Type Constructors -More than one values or methods are defined in the same scope with the -same name, we model +A type constructor is represented internally much like a polymorphic method type. +~\lstinline@[$\pm$ $a_1$ >: $L_1$ <: $U_1 \commadots \pm a_n$ >: $L_n$ <: $U_n$] $T$@~ represents a type that is expected by a type constructor parameter (\sref{sec:type-params}) or an abstract type constructor binding (\sref{sec:typedcl}) with the corresponding type parameter clause. -An overloaded type consisting of type alternatives $T_1 \commadots -T_n (n \geq 2)$ is denoted internally $T_1 \overload \ldots \overload T_n$. +(@) Consider this fragment of the `Iterable[+X]`{.scala} class: + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} + trait Iterable[+X] { + def flatMap[newType[+X] <: Iterable[X], S](f: X => newType[S]): newType[S] + } + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -\example The definitions -\begin{lstlisting} -def println: Unit -def println(s: String): Unit = $\ldots$ -def println(x: Float): Unit = $\ldots$ -def println(x: Float, width: Int): Unit = $\ldots$ -def println[A](x: A)(tostring: A => String): Unit = $\ldots$ -\end{lstlisting} -define a single function \code{println} which has an overloaded -type. -\begin{lstlisting} -println: => Unit $\overload$ - (String) Unit $\overload$ - (Float) Unit $\overload$ - (Float, Int) Unit $\overload$ - [A] (A) (A => String) Unit -\end{lstlisting} + Conceptually, the type constructor `Iterable` is a name for the + anonymous type `[+X] Iterable[X]`, which may be passed to the + `newType` type constructor parameter in `flatMap`. -\example The definitions -\begin{lstlisting} -def f(x: T): T = $\ldots$ -val f = 0 -\end{lstlisting} -define a function \code{f} which has type ~\lstinline@(x: T)T $\overload$ Int@. -} -\section{Base Types and Member Definitions} -\label{sec:base-classes-member-defs} +Base Types and Member Definitions +--------------------------------- Types of class members depend on the way the members are referenced. Central here are three notions, namely: -\begin{enumerate} -\item the notion of the set of base types of a type $T$, -\item the notion of a type $T$ in some class $C$ seen from some - prefix type $S$, -\item the notion of the set of member bindings of some type $T$. -\end{enumerate} +#. the notion of the set of base types of a type $T$, +#. the notion of a type $T$ in some class $C$ seen from some + prefix type $S$, +#. the notion of the set of member bindings of some type $T$. + + These notions are defined mutually recursively as follows. -1. The set of {\em base types} of a type is a set of class types, -given as follows. -\begin{itemize} -\item -The base types of a class type $C$ with parents $T_1 \commadots T_n$ are -$C$ itself, as well as the base types of the compound type -~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@. -\item -The base types of an aliased type are the base types of its alias. -\item -The base types of an abstract type are the base types of its upper bound. -\item -The base types of a parameterized type -~\lstinline@$C$[$T_1 \commadots T_n$]@~ are the base types -of type $C$, where every occurrence of a type parameter $a_i$ -of $C$ has been replaced by the corresponding parameter type $T_i$. -\item -The base types of a singleton type \lstinline@$p$.type@ are the base types of -the type of $p$. -\item -The base types of a compound type -~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@~ -are the {\em reduced union} of the base -classes of all $T_i$'s. This means: -Let the multi-set $\SS$ be the multi-set-union of the -base types of all $T_i$'s. -If $\SS$ contains several type instances of the same class, say -~\lstinline@$S^i$#$C$[$T^i_1 \commadots T^i_n$]@~ $(i \in I)$, then -all those instances -are replaced by one of them which conforms to all -others. It is an error if no such instance exists. It follows that the reduced union, if it exists, -produces a set of class types, where different types are instances of different classes. -\item -The base types of a type selection \lstinline@$S$#$T$@ are -determined as follows. If $T$ is an alias or abstract type, the -previous clauses apply. Otherwise, $T$ must be a (possibly -parameterized) class type, which is defined in some class $B$. Then -the base types of \lstinline@$S$#$T$@ are the base types of $T$ -in $B$ seen from the prefix type $S$. -\item -The base types of an existential type \lstinline@$T$ forSome {$\,Q\,$}@ are -all types \lstinline@$S$ forSome {$\,Q\,$}@ where $S$ is a base type of $T$. -\end{itemize} +#. The set of _base types_ of a type is a set of class types, + given as follows. + + - The base types of a class type $C$ with parents $T_1 \commadots T_n$ are + $C$ itself, as well as the base types of the compound type + ~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@. + - The base types of an aliased type are the base types of its alias. + - The base types of an abstract type are the base types of its upper bound. + - The base types of a parameterized type + ~\lstinline@$C$[$T_1 \commadots T_n$]@~ are the base types + of type $C$, where every occurrence of a type parameter $a_i$ + of $C$ has been replaced by the corresponding parameter type $T_i$. + - The base types of a singleton type \lstinline@$p$.type@ are the base types of + the type of $p$. + - The base types of a compound type + ~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@~ + are the _reduced union_ of the base + classes of all $T_i$'s. This means: + Let the multi-set $\SS$ be the multi-set-union of the + base types of all $T_i$'s. + If $\SS$ contains several type instances of the same class, say + ~\lstinline@$S^i$#$C$[$T^i_1 \commadots T^i_n$]@~ $(i \in I)$, then + all those instances + are replaced by one of them which conforms to all + others. It is an error if no such instance exists. It follows that the reduced union, if it exists, + produces a set of class types, where different types are instances of different classes. + - The base types of a type selection \lstinline@$S$#$T$@ are + determined as follows. If $T$ is an alias or abstract type, the + previous clauses apply. Otherwise, $T$ must be a (possibly + parameterized) class type, which is defined in some class $B$. Then + the base types of \lstinline@$S$#$T$@ are the base types of $T$ + in $B$ seen from the prefix type $S$. + - The base types of an existential type \lstinline@$T$ forSome {$\,Q\,$}@ are + all types \lstinline@$S$ forSome {$\,Q\,$}@ where $S$ is a base type of $T$. 2. The notion of a type $T$ {\em in class $C$ seen from some prefix type @@ -734,18 +727,21 @@ is defined in some other class $D$, and $S$ is some prefix type, then we use ``$T$ seen from $S$'' as a shorthand for ``$T$ in $D$ seen from $S$''. -3. The {\em member bindings} of a type $T$ are (1) all bindings $d$ such that +3. The _member bindings_ of a type $T$ are (1) all bindings $d$ such that there exists a type instance of some class $C$ among the base types of $T$ and there exists a definition or declaration $d'$ in $C$ such that $d$ results from $d'$ by replacing every type $T'$ in $d'$ by $T'$ in $C$ seen from $T$, and (2) all bindings of the type's refinement (\sref{sec:refinements}), if it has one. -The {\em definition} of a type projection \lstinline@$S$#$t$@ is the member +The _definition_ of a type projection \lstinline@$S$#$t$@ is the member binding $d_t$ of the type $t$ in $S$. In that case, we also say -that \lstinline@$S$#$t$@ {\em is defined by} $d_t$. +that \lstinline@$S$#$t$@ _is defined by_ $d_t$. share a to -\section{Relations between types} + + +Relations between types +----------------------- We define two relations between types. \begin{quote}\begin{tabular}{l@{\gap}l@{\gap}l} @@ -755,7 +751,7 @@ in all contexts. \em Conformance & $T \conforms U$ & Type $T$ conforms to type $U$. \end{tabular}\end{quote} -\subsection{Type Equivalence} +### Type Equivalence \label{sec:type-equiv} Equivalence $(\equiv)$ between types is the smallest congruence\footnote{ A @@ -801,7 +797,7 @@ another, the result types as well as variances, lower and upper bounds of corresponding type parameters are equivalent. \end{itemize} -\subsection{Conformance} +### Conformance \label{sec:conformance} The conformance relation $(\conforms)$ is the smallest @@ -875,7 +871,7 @@ $[a'_1 \commadots a'_n ]$, where an $a_i$ or $a'_i$ may include a variance annot \end{itemize} A declaration or definition in some compound type of class type $C$ -{\em subsumes} another +_subsumes_ another declaration of the same name in some compound type or class type $C'$, if one of the following holds. \begin{itemize} \item @@ -899,8 +895,7 @@ $L \conforms t \conforms U$. \end{itemize} The $(\conforms)$ relation forms pre-order between types, -i.e.\ it is transitive and reflexive. {\em -least upper bounds} and {\em greatest lower bounds} of a set of types +i.e.\ it is transitive and reflexive. _least upper bounds_ and _greatest lower bounds_ of a set of types are understood to be relative to that order. \paragraph{Note} The least upper bound or greatest lower bound @@ -928,10 +923,10 @@ greatest lower of \code{A} and \code{B}. If there are several least upper bounds or greatest lower bounds, the Scala compiler is free to pick any one of them. -\subsection{Weak Conformance}\label{sec:weakconformance} +### Weak Conformance In some situations Scala uses a more genral conformance relation. A -type $S$ {\em weakly conforms} +type $S$ _weakly conforms_ to a type $T$, written $S \conforms_w T$, if $S \conforms T$ or both $S$ and $T$ are primitive number types and $S$ precedes $T$ in the following ordering. @@ -944,29 +939,33 @@ Long $\conforms_w$ Float Float $\conforms_w$ Double \end{lstlisting} -A {\em weak least upper bound} is a least upper bound with respect to +A _weak least upper bound_ is a least upper bound with respect to weak conformance. -\section{Volatile Types} -\label{sec:volatile-types} + +Volatile Types +-------------- + + Type volatility approximates the possibility that a type parameter or abstract type instance of a type does not have any non-null values. As explained in (\sref{sec:paths}), a value member of a volatile type cannot appear in a path. -A type is {\em volatile} if it falls into one of four categories: +A type is _volatile_ if it falls into one of four categories: A compound type ~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@~ is volatile if one of the following two conditions hold. -\begin{enumerate} -\item One of $T_2 \commadots T_n$ is a type parameter or abstract type, or -\item $T_1$ is an abstract type and and either the refinement $R$ - or a type $T_j$ for $j > 1$ contributes an abstract member - to the compound type, or -\item one of $T_1 \commadots T_n$ is a singleton type. -\end{enumerate} -Here, a type $S$ {\em contributes an abstract member} to a type $T$ if + +#. One of $T_2 \commadots T_n$ is a type parameter or abstract type, or +#. $T_1$ is an abstract type and and either the refinement $R$ + or a type $T_j$ for $j > 1$ contributes an abstract member + to the compound type, or +#. one of $T_1 \commadots T_n$ is a singleton type. + + +Here, a type $S$ _contributes an abstract member_ to a type $T$ if $S$ contains an abstract member that is also a member of $T$. A refinement $R$ contributes an abstract member to a type $T$ if $R$ contains an abstract declaration which is also a member of $T$. @@ -981,30 +980,30 @@ type of path $p$ is volatile. An existential type ~\lstinline@$T$ forSome {$\,Q\,$}@~ is volatile if $T$ is volatile. -\section{Type Erasure} -\label{sec:erasure} -A type is called {\em generic} if it contains type arguments or type variables. -{\em Type erasure} is a mapping from (possibly generic) types to +Type Erasure +------------ + +A type is called _generic_ if it contains type arguments or type variables. +_Type erasure_ is a mapping from (possibly generic) types to non-generic types. We write $|T|$ for the erasure of type $T$. The erasure mapping is defined as follows. -\begin{itemize} -\item The erasure of an alias type is the erasure of its right-hand side. %@M -\item The erasure of an abstract type is the erasure of its upper bound. -\item The erasure of the parameterized type \lstinline@scala.Array$[T_1]$@ is + +- The erasure of an alias type is the erasure of its right-hand side. %@M +- The erasure of an abstract type is the erasure of its upper bound. +- The erasure of the parameterized type \lstinline@scala.Array$[T_1]$@ is \lstinline@scala.Array$[|T_1|]$@. - \item The erasure of every other parameterized type $T[T_1 \commadots T_n]$ is $|T|$. -\item The erasure of a singleton type \lstinline@$p$.type@ is the - erasure of the type of $p$. -\item The erasure of a type projection \lstinline@$T$#$x$@ is \lstinline@|$T$|#$x$@. -\item The erasure of a compound type -~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@ is the erasure of the intersection dominator of +- The erasure of every other parameterized type $T[T_1 \commadots T_n]$ is $|T|$. +- The erasure of a singleton type \lstinline@$p$.type@ is the + erasure of the type of $p$. +- The erasure of a type projection \lstinline@$T$#$x$@ is \lstinline@|$T$|#$x$@. +- The erasure of a compound type + ~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@ is the erasure of the intersection dominator of $T_1 \commadots T_n$. -\item The erasure of an existential type ~\lstinline@$T$ forSome {$\,Q\,$}@ +- The erasure of an existential type ~\lstinline@$T$ forSome {$\,Q\,$}@ is $|T|$. -\end{itemize} -The {\em intersection dominator} of a list of types $T_1 \commadots +The _intersection dominator_ of a list of types $T_1 \commadots T_n$ is computed as follows. Let $T_{i_1} \commadots T_{i_m}$ be the subsequence of types $T_i$ which are not supertypes of some other type $T_j$. diff --git a/README.md b/README.md index 4c078b8bae47..dcdaf3a250ae 100644 --- a/README.md +++ b/README.md @@ -66,6 +66,7 @@ code fragment. replaced with \\uABCD. - The macro \URange{ABCD}{DCBA} used for unicode character ranges can be replaced with \\uABCD-\\uDBCA. +- The macro \commadots can be replaced with ` , … , `. - There is no adequate replacement for `\textsc{...}` (small caps) in pandoc markdown. While unicode contains a number of small capital letters, it is notably missing Q and X as these glyphs are intended for phonetic spelling, diff --git a/build.sh b/build.sh index 64e1b9f7c299..541256d46868 100755 --- a/build.sh +++ b/build.sh @@ -3,8 +3,8 @@ find . -name "*.md" | \ cat 01-title.md \ 02-preface.md \ 03-lexical-syntax.md \ - 04-identifiers-names-and-scopes.md > build/ScalaReference.md -# 05-types.md \ + 04-identifiers-names-and-scopes.md \ + 05-types.md > build/ScalaReference.md # 06-basic-declarations-and-definitions.md \ # 07-classes-and-objects.md \ # 08-expressions.md \ @@ -24,11 +24,12 @@ pandoc -f markdown \ --number-sections \ --bibliography=Scala.bib \ --template=resources/scala-ref-template.html5 \ - --self-contained \ - --mathml \ + --mathjax \ -o build/ScalaReference.html \ build/ScalaReference.md +cp -Rf resources build/ + # pdf generation - not working yet #pandoc -f markdown \ # --standalone \ diff --git a/resources/style.css b/resources/style.css index cfe9053bb7cf..833e76815e15 100644 --- a/resources/style.css +++ b/resources/style.css @@ -24,10 +24,6 @@ pre { border: 1px solid #333; } -code { - background-color: #EEE; -} - code > span { font-weight: normal !important; } From eb3e02ad36ec05769bb1d98302627bd3ca871864 Mon Sep 17 00:00:00 2001 From: Iain McGinniss Date: Tue, 23 Oct 2012 15:22:51 +0100 Subject: [PATCH 008/826] MathJAX configuration for inline math inside code blocks --- resources/scala-ref-template.html5 | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/resources/scala-ref-template.html5 b/resources/scala-ref-template.html5 index 33d6b26ef843..424170d3d876 100644 --- a/resources/scala-ref-template.html5 +++ b/resources/scala-ref-template.html5 @@ -26,6 +26,15 @@ $endif$ $for(css)$ $endfor$ + $if(math)$ $math$ $endif$ From 3340862f0140b7f70dbea250a60fc4e2f41ff01b Mon Sep 17 00:00:00 2001 From: Iain McGinniss Date: Tue, 23 Oct 2012 15:27:25 +0100 Subject: [PATCH 009/826] accidentally committed OS resource --- .DS_Store | Bin 6148 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 .DS_Store diff --git a/.DS_Store b/.DS_Store deleted file mode 100644 index fe0e33b7c27f03b9d5f45f3b7ed8e736038d3abe..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6148 zcmeHKOH0E*5T5Nr6IAF$^cXxBY4K4H9zv+#QD~tDE1H;M10g9%Y7aFUPyQQ!j=#s5 z-L15?Ud6`@%zl%3B+Qqvn*jjfjQu7+4FC*O!jg&03ZXdZl9aTkf+*xYd~cGDyfF5b za@p}S8K8Gp1rNp$KnU~i@6{WHL7FuhZ=zJLRM*xG(=;~wy&&@Ai4%__KfUY><4Gs* z2cDZ;Njr11aq75$~aFXYy zVVJcSV|#D^^t|g%AM(d1MW4X$Ov;wV89bvg*T;P)iNZL#LoZdBkiY;^h_TNEZpohe zQh#5kEBg7=@r)NnW`G%B239ek_flhHRgitm05kBf8KC{aLM5~{77FFofr}gg5a~Bk z3feSFP>rS0)>tUS2#Qdph^kcR5kshQ^jkX5)>tT1by=hH|Lp7ef3b+Km;q+sPca}W?M~almh{=W)Eu3)7U~Tu3FQ?EKT6P$ iM=|EoQM`*P1^pHoh_=Q;A$m~wM?liR3p4Po47>xfY=tTS From bb53357a77105d4c01cc0c7566497f05a7620878 Mon Sep 17 00:00:00 2001 From: Iain McGinniss Date: Fri, 26 Oct 2012 22:53:29 +0100 Subject: [PATCH 010/826] types chapter fully converted. Added link to jquery and some experimental code for a fixed pop-out version of the table of contents, which is currently disabled. --- 03-lexical-syntax.md | 6 +- 04-identifiers-names-and-scopes.md | 24 +- 05-types.md | 805 ++++++++++++++--------------- 16-references.md | 6 + README.md | 17 +- build.sh | 5 +- resources/ScalaReference.js | 20 + resources/scala-ref-template.html5 | 2 + resources/style.css | 20 +- 9 files changed, 480 insertions(+), 425 deletions(-) create mode 100644 16-references.md create mode 100644 resources/ScalaReference.js diff --git a/03-lexical-syntax.md b/03-lexical-syntax.md index cbc09d2c9a24..8fc6d30cf698 100644 --- a/03-lexical-syntax.md +++ b/03-lexical-syntax.md @@ -23,7 +23,7 @@ classes (Unicode general category given in parentheses): #. Whitespace characters. `\u0020 | \u0009 | \u000D | \u000A`{.grammar} #. Letters, which include lower case letters(Ll), upper case letters(Lu), titlecase letters(Lt), other letters(Lo), letter numerals(Nl) and the - two characters \\u0024 ‘$’ and \\u005F ‘_’, which both count as upper case + two characters \\u0024 ‘\\$’ and \\u005F ‘_’, which both count as upper case letters #. Digits ` ‘0’ | … | ‘9’ `{.grammar} #. Parentheses ` ‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’ `{.grammar} @@ -70,9 +70,9 @@ decomposes into the three identifiers `big_bob`, `++=`, and _variable identifiers_, which start with a lower case letter, and _constant identifiers_, which do not. -The ‘$’ character is reserved +The ‘\$’ character is reserved for compiler-synthesized identifiers. User programs should not define -identifiers which contain ‘$’ characters. +identifiers which contain ‘\$’ characters. The following names are reserved words instead of being members of the syntactic class `id` of lexical identifiers. diff --git a/04-identifiers-names-and-scopes.md b/04-identifiers-names-and-scopes.md index 6a7393db94be..1266fce2f672 100644 --- a/04-identifiers-names-and-scopes.md +++ b/04-identifiers-names-and-scopes.md @@ -41,18 +41,18 @@ val x = 1; neither binding of `x` shadows the other. Consequently, the reference to `x` in the third line above would be ambiguous. -A reference to an unqualified (type- or term-) identifier _x_ is bound +A reference to an unqualified (type- or term-) identifier $x$ is bound by the unique binding, which - defines an entity with name $x$ in the same namespace as the identifier, and -- shadows all other bindings that define entities with name _x_ in that +- shadows all other bindings that define entities with name $x$ in that namespace. -It is an error if no such binding exists. If _x_ is bound by an -import clause, then the simple name _x_ is taken to be equivalent to -the qualified name to which _x_ is mapped by the import clause. If _x_ -is bound by a definition or declaration, then _x_ refers to the entity -introduced by that binding. In that case, the type of _x_ is the type +It is an error if no such binding exists. If $x$ is bound by an +import clause, then the simple name $x$ is taken to be equivalent to +the qualified name to which $x$ is mapped by the import clause. If $x$ +is bound by a definition or declaration, then $x$ refers to the entity +introduced by that binding. In that case, the type of $x$ is the type of the referenced entity. (@) Assume the following two definitions of a objects named @@ -95,9 +95,9 @@ of the referenced entity. }}}}}} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -A reference to a qualified (type- or term-) identifier `e.x` refers to -the member of the type _T_ of _e_ which has the name _x_ in the same -namespace as the identifier. It is an error if _T_ is not a -[value type](#value-types). The type of `e.x` is the member type of the -referenced entity in _T_. +A reference to a qualified (type- or term-) identifier $e.x$ refers to +the member of the type $T$ of $e$ which has the name $x$ in the same +namespace as the identifier. It is an error if $T$ is not a +[value type](#value-types). The type of $e.x$ is the member type of the +referenced entity in $T$. diff --git a/05-types.md b/05-types.md index cd28439e71b1..a5268bf0e608 100644 --- a/05-types.md +++ b/05-types.md @@ -29,12 +29,12 @@ Value types are either _concrete_ or _abstract_. Every concrete value type can be represented as a _class type_, i.e. a [type designator](#type-designators) that refers to a -a [class or a trait](#class-definitions) [^1], or as a +[class or a trait](#class-definitions) [^1], or as a [compound type](#compound-types) representing an intersection of types, possibly with a [refinement](#compound-types) that further constrains the types of its members. Abstract value types are introduced by [type parameters](#type-parameters) and [abstract type bindings](#type-declarations-and-type-aliases). @@ -76,21 +76,21 @@ and in that function form a central role in Scala's type system. A path is one of the following. - The empty path ε (which cannot be written explicitly in user programs). -- `C.this`, where _C_ references a class. - The path `this` is taken as a shorthand for `C.this` where - _C_ is the name of the class directly enclosing the reference. -- `p.x` where _p_ is a path and _x_ is a stable member of _p_. +- `$C$.this`, where $C$ references a class. + The path `this` is taken as a shorthand for `$C$.this` where + $C$ is the name of the class directly enclosing the reference. +- `$p$.$x$` where $p$ is a path and $x$ is a stable member of $p$. _Stable members_ are packages or members introduced by object definitions or by value definitions of [non-volatile types](#volatile-types). -- `C.super.x` or `C.super[M].x` - where _C_ references a class and _x_ references a - stable member of the super class or designated parent class _M_ of _C_. - The prefix `super`{.scala} is taken as a shorthand for `C.super` where - _C_ is the name of the class directly enclosing the reference. - +- `$C$.super.$x$` or `$C$.super[$M$].$x$` + where $C$ references a class and $x$ references a + stable member of the super class or designated parent class $M$ of $C$. + The prefix `super`{.scala} is taken as a shorthand for `$C$.super` where + $C$ is the name of the class directly enclosing the reference. A _stable identifier_ is a path which ends in an identifier. + Value Types ----------- @@ -103,10 +103,10 @@ forms. SimpleType ::= Path ‘.’ type ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -A singleton type is of the form `p.type`{.scala}, where _p_ is a +A singleton type is of the form `$p$.type`{.scala}, where $p$ is a path pointing to a value expected to [conform](#expression-typing) to `scala.AnyRef`{.scala}. The type denotes the set of values -consisting of `null`{.scala} and the value denoted by _p_. +consisting of `null`{.scala} and the value denoted by $p$. A _stable type_ is either a singleton type or a type which is declared to be a subtype of trait `scala.Singleton`{.scala}. @@ -117,12 +117,13 @@ declared to be a subtype of trait `scala.Singleton`{.scala}. SimpleType ::= SimpleType ‘#’ id ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -A type projection `T#x`{.scala} references the type member named -_x_ of type _T_. +A type projection `$T$#$x$`{.scala} references the type member named +$x$ of type $T$. ### Type Designators @@ -134,22 +135,22 @@ SimpleType ::= StableId A type designator refers to a named value type. It can be simple or qualified. All such type designators are shorthands for type projections. -Specifically, the unqualified type name _t_ where _t_ is bound in some -class, object, or package _C_ is taken as a shorthand for -`C.this.type#t`{.scala}. If _t_ is -not bound in a class, object, or package, then _t_ is taken as a -shorthand for `ε.type#t`. +Specifically, the unqualified type name $t$ where $t$ is bound in some +class, object, or package $C$ is taken as a shorthand for +`$C$.this.type#$t$`{.scala}. If $t$ is +not bound in a class, object, or package, then $t$ is taken as a +shorthand for `ε.type#$t$`. A qualified type designator has the form `p.t` where `p` is a [path](#paths) and _t_ is a type name. Such a type designator is equivalent to the type projection `p.type#t`{.scala}. (@) Some type designators and their expansions are listed below. We assume - a local type parameter _t_, a value `maintable` - with a type member `Node` and the standard class `scala.Int`, + a local type parameter $t$, a value `maintable` + with a type member `Node` and the standard class `scala.Int`{.scala}, -------------------- -------------------------- - t $\epsilon$.type#t + t ε.type#t Int scala.type#Int scala.Int scala.type#Int data.maintable.Node data.maintable.type#Node @@ -163,16 +164,16 @@ SimpleType ::= SimpleType TypeArgs TypeArgs ::= ‘[’ Types ‘]’ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -A parameterized type T[ U~1~ , … , U~n~ ] consists of a type -designator _T_ and type parameters _U~1~ , … , U~n~_ where -_n ≥ 1_. _T_ must refer to a type constructor which takes _n_ type -parameters _a~1~ , … , s a~n~_. +A parameterized type $T[ U_1 , \ldots , U_n ]$ consists of a type +designator $T$ and type parameters $U_1 , \ldots , U_n$ where +$n \geq 1$. $T$ must refer to a type constructor which takes $n$ type +parameters $a_1 , \ldots , a_n$. -Say the type parameters have lower bounds _L~1~ , … , L~n~_ and -upper bounds _U~1~ … U~n~_. The parameterized type is +Say the type parameters have lower bounds $L_1 , \ldots , L_n$ and +upper bounds $U_1 , \ldots , U_n$. The parameterized type is well-formed if each actual type parameter -_conforms to its bounds_, i.e. _σ L~i~ <: T~i~ <: σ U~i~_ where σ is the -substitution [ _a~1~_ := _T~1~_ , … , _a~n~_ := _T~n~_ ]. +_conforms to its bounds_, i.e. $σ L_i <: T_i <: σ U_i$ where $σ$ is the +substitution $[ a_1 := T_1 , \ldots , a_n := T_n ]$. (@param-types) Given the partial type definitions: @@ -219,8 +220,8 @@ substitution [ _a~1~_ := _T~1~_ , … , _a~n~_ := _T~n~_ ]. SimpleType ::= ‘(’ Types ‘)’ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -A tuple type (T~1~ , … , T~n~) is an alias for the -class `scala.Tuple`~n~`[`T~1~`, … , `T~n~`]`, where _n ≥ 2_. +A tuple type $(T_1 , \ldots , T_n)$ is an alias for the +class `scala.Tuple$_n$[$T_1$, … , $T_n$]`, where $n \geq 2$. Tuple classes are case classes whose fields can be accessed using selectors `_1` , … , `_n`. Their functionality is @@ -230,14 +231,14 @@ standard Scala library (they might also add other methods and implement other traits). ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} -case class Tuple_n[+T1, … , +Tn](_1: T1, … , _n: Tn) -extends Product_n[T1, … , Tn] {} +case class Tuple$n$[+T1, … , +$T_n$](_1: T1, … , _n: $T_n$) +extends Product_n[T1, … , $T_n$] {} -trait Product_n[+T1, … , +Tn] { - override def arity = n +trait Product_n[+T1, … , +$T_n$] { + override def arity = $n$ def _1: T1 … - def _n: Tn + def _n: $T_n$ } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -247,9 +248,9 @@ trait Product_n[+T1, … , +Tn] { AnnotType ::= SimpleType {Annotation} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -An annotated type _T a~1~ , … , a~n~_ +An annotated type $T$ `$a_1 , \ldots , a_n$` attaches [annotations](#user-defined-annotations) -_a~1~ , … , a~n~_ to the type _T_. +$a_1 , \ldots , a_n$ to the type $T$. (@) The following type adds the `@suspendable`{.scala} annotation to the type `String`{.scala}: @@ -270,12 +271,12 @@ RefineStat ::= Dcl | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -A compound type `T1 with … with Tn { R }` +A compound type `$T_1$ with … with $T_n$ { $R$ }` represents objects with members as given in the component types -_T1 , … , Tn_ and the refinement `{ R }`. A refinement -`{ R }` contains declarations and type definitions. +$T_1 , \ldots , T_n$ and the refinement `{ $R$ }`. A refinement +`{ $R$ }` contains declarations and type definitions. If a declaration or definition overrides a declaration or definition in -one of the component types _T1 , … , T_n_, the usual rules for +one of the component types $T_1 , \ldots , T_n$, the usual rules for [overriding](#overriding) apply; otherwise the declaration or definition is said to be “structural” [^2]. @@ -291,11 +292,11 @@ definition within the refinement. This restriction does not apply to the function's result type. If no refinement is given, the empty refinement is implicitly added, -i.e.\ `T1 with … with Tn`{.scala} is a shorthand for -`T1 with … with Tn {}`{.scala}. +i.e.\ `$T_1$ with … with $T_n$`{.scala} is a shorthand for +`$T_1$ with … with $T_n$ {}`{.scala}. A compound type may also consist of just a refinement -`{ R }` with no preceding component types. Such a type is +`{ $R$ }` with no preceding component types. Such a type is equivalent to `AnyRef{ R }`{.scala}. (@) The following example shows how to declare and use a function which @@ -335,10 +336,11 @@ equivalent to `AnyRef{ R }`{.scala}. InfixType ::= CompoundType {id [nl] CompoundType} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -An infix type _T~1~ op T~2~_ consists of an infix -operator _op_ which gets applied to two type operands _T~1~_ and -_T~2~_. The type is equivalent to the type application -`op[T₁, T₂]`. The infix operator _op_ may be an arbitrary identifier, +An infix type `$T_1$ \mathit{op} $T_2$` consists of an infix +operator $\mathit{op}$ which gets applied to two type operands $T_1$ and +$T_2$. The type is equivalent to the type application +`$\mathit{op}$[$T_1$, $T_2$]`. The infix operator $\mathit{op}$ may be an +arbitrary identifier, except for `*`, which is reserved as a postfix modifier denoting a [repeated parameter type](#repeated-parameters). @@ -349,11 +351,13 @@ ending in a colon ‘:’ are right-associative; all other operators are left-associative. In a sequence of consecutive type infix operations -$t_0 \, op \, t_1 \, op_2 \, … \, op_n \, t_n$, -all operators $\op_1 , … , \op_n$ must have the same +$t_0 \, \mathit{op} \, t_1 \, \mathit{op_2} \, \ldots \, \mathit{op_n} \, t_n$, +all operators $\mathit{op}_1 , \ldots , \mathit{op}_n$ must have the same associativity. If they are all left-associative, the sequence is -interpreted as `(… (t_0 op_1 t_1) op_2 …) op_n t_n`, -otherwise it is interpreted as $t_0 op_1 (t_1 op_2 ( … op_n t_n) …)$. +interpreted as +$(\ldots (t_0 \mathit{op_1} t_1) \mathit{op_2} \ldots) \mathit{op_n} t_n$, +otherwise it is interpreted as +$t_0 \mathit{op_1} (t_1 \mathit{op_2} ( \ldots \mathit{op_n} t_n) \ldots)$. ### Function Types @@ -371,18 +375,19 @@ An argument type of the form $\Rightarrow T$ represents a [call-by-name parameter](#by-name-parameters) of type $T$. Function types associate to the right, e.g. -`S => T => U` is the same as `S => (T => U)`. +$S \Rightarrow T \Rightarrow U$ is the same as +$S \Rightarrow (T \Rightarrow U)$. Function types are shorthands for class types that define `apply` functions. Specifically, the $n$-ary function type -`(T1 , … , Tn) => U` is a shorthand for the class type -`Function_n[T1 , … , Tn, U]`. Such class +$(T_1 , \ldots , T_n) \Rightarrow U$ is a shorthand for the class type +`Function$_n$[T1 , … , $T_n$, U]`. Such class types are defined in the Scala library for $n$ between 0 and 9 as follows. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ {.scala} package scala -trait Function_n[-T1 , … , -Tn, +R] { - def apply(x1: T1 , … , xn: Tn): R +trait Function_n[-T1 , … , -T$_n$, +R] { + def apply(x1: T1 , … , x$_n$: T$_n$): R override def toString = "" } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -400,29 +405,30 @@ ExistentialDcl ::= ‘type’ TypeDcl | ‘val’ ValDcl ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -An existential type has the form `T forSome { Q }` -where _Q_ is a sequence of +An existential type has the form `$T$ forSome { $Q$ }` +where $Q$ is a sequence of [type declarations](#type-declarations-and-type-aliases). -Let $t_1[\mathit{tps}_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}_n] >: L_n <: U_n$ +Let +$t_1[\mathit{tps}_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}_n] >: L_n <: U_n$ be the types declared in $Q$ (any of the -type parameter sections [ _tps~i~_ ] might be missing). -The scope of each type _t~i~_ includes the type _T_ and the existential clause _Q_. -The type variables _t~i~_ are said to be _bound_ in the type `T forSome { Q }`. -Type variables which occur in a type _T_ but which are not bound in _T_ are said -to be _free_ in _T_. - -%%% iainmcgin: to here - -A _type instance_ of ~\lstinline@$T$ forSome {$\,Q\,$}@ -is a type $\sigma T$ where $\sigma$ is a substitution over $t_1 \commadots t_n$ -such that, for each $i$, $\sigma L_i \conforms \sigma t_i \conforms \sigma U_i$. -The set of values denoted by the existential type ~\lstinline@$T$ forSome {$\,Q\,$}@~ +type parameter sections `[ $\mathit{tps}_i$ ]` might be missing). +The scope of each type $t_i$ includes the type $T$ and the existential clause +$Q$. +The type variables $t_i$ are said to be _bound_ in the type +`$T$ forSome { $Q$ }`. +Type variables which occur in a type $T$ but which are not bound in $T$ are said +to be _free_ in $T$. + +A _type instance_ of `$T$ forSome { $Q$ }` +is a type $\sigma T$ where $\sigma$ is a substitution over $t_1 , \ldots , t_n$ +such that, for each $i$, $\sigma L_i <: \sigma t_i <: \sigma U_i$. +The set of values denoted by the existential type `$T$ forSome {$\,Q\,$}` is the union of the set of values of all its type instances. -A _skolemization_ of ~\lstinline@$T$ forSome {$\,Q\,$}@~ is +A _skolemization_ of `$T$ forSome { $Q$ }` is a type instance $\sigma T$, where $\sigma$ is the substitution -$[t'_1/t_1 \commadots t'_n/t_n]$ and each $t'_i$ is a fresh abstract type +$[t'_1/t_1 , \ldots , t'_n/t_n]$ and each $t'_i$ is a fresh abstract type with lower bound $\sigma L_i$ and upper bound $\sigma U_i$. #### Simplification Rules @@ -430,33 +436,33 @@ with lower bound $\sigma L_i$ and upper bound $\sigma U_i$. Existential types obey the following four equivalences: #. Multiple for-clauses in an existential type can be merged. E.g., -~\lstinline@$T$ forSome {$\,Q\,$} forSome {$\,Q'\,$}@~ +`$T$ forSome { $Q$ } forSome { $Q'$ }` is equivalent to -~\lstinline@$T$ forSome {$\,Q\,$;$\,Q'\,$}@. +`$T$ forSome { $Q$ ; $Q'$}`. #. Unused quantifications can be dropped. E.g., -~\lstinline@$T$ forSome {$\,Q\,$;$\,Q'\,$}@~ +`$T$ forSome { $Q$ ; $Q'$}` where none of the types defined in $Q'$ are referred to by $T$ or $Q$, is equivalent to -~\lstinline@$T$ forSome {$\,Q\,$}@. +`$T$ forSome {$ Q $}`. #. An empty quantification can be dropped. E.g., -~\lstinline@$T$ forSome { }@~ is equivalent to ~\lstinline@$T$@. -#. An existential type ~\lstinline@$T$ forSome {$\,Q\,$}@~ where $Q$ contains -a clause ~\lstinline@type $t[\tps] >: L <: U$@ is equivalent -to the type ~\lstinline@$T'$ forSome {$\,Q\,$}@~ where $T'$ results from $T$ by replacing every -covariant occurrence (\sref{sec:variances}) of $t$ in $T$ by $U$ and by replacing every -contravariant occurrence of $t$ in $T$ by $L$. +`$T$ forSome { }` is equivalent to $T$. +#. An existential type `$T$ forSome { $Q$ }` where $Q$ contains +a clause `type $t[\mathit{tps}] >: L <: U$` is equivalent +to the type `$T'$ forSome { $Q$ }` where $T'$ results from $T$ by replacing +every [covariant occurrence](#variance-annotations) of $t$ in $T$ by $U$ and by +replacing every contravariant occurrence of $t$ in $T$ by $L$. #### Existential Quantification over Values As a syntactic convenience, the bindings clause in an existential type may also contain -value declarations \lstinline@val $x$: $T$@. -An existential type ~\lstinline@$T$ forSome { $Q$; val $x$: $S\,$;$\,Q'$ }@~ +value declarations `val $x$: $T$`. +An existential type `$T$ forSome { $Q$; val $x$: $S\,$;$\,Q'$ }` is treated as a shorthand for the type -~\lstinline@$T'$ forSome { $Q$; type $t$ <: $S$ with Singleton; $Q'$ }@, where $t$ is a fresh -type name and $T'$ results from $T$ by replacing every occurrence of -\lstinline@$x$.type@ with $t$. +`$T'$ forSome { $Q$; type $t$ <: $S$ with Singleton; $Q'$ }`, where $t$ is a +fresh type name and $T'$ results from $T$ by replacing every occurrence of +`$x$.type` with $t$. #### Placeholder Syntax for Existential Types @@ -465,26 +471,29 @@ WildcardType ::= ‘_’ TypeBounds ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Scala supports a placeholder syntax for existential types. -A _wildcard type_ is of the form ~\lstinline@_$\;$>:$\,L\,$<:$\,U$@. Both bound -clauses may be omitted. If a lower bound clause \lstinline@>:$\,L$@ is missing, -\lstinline@>:$\,$scala.Nothing@~ -is assumed. If an upper bound clause ~\lstinline@<:$\,U$@ is missing, -\lstinline@<:$\,$scala.Any@~ is assumed. A wildcard type is a shorthand for an -existentially quantified type variable, where the existential quantification is implicit. +A _wildcard type_ is of the form `_$\;$>:$\,L\,$<:$\,U$`. Both bound +clauses may be omitted. If a lower bound clause `>:$\,L$` is missing, +`>:$\,$scala.Nothing` +is assumed. If an upper bound clause `<:$\,U$` is missing, +`<:$\,$scala.Any` is assumed. A wildcard type is a shorthand for an +existentially quantified type variable, where the existential quantification is +implicit. A wildcard type must appear as type argument of a parameterized type. -Let $T = p.c[\targs,T,\targs']$ be a parameterized type where $\targs, \targs'$ may be empty and -$T$ is a wildcard type ~\lstinline@_$\;$>:$\,L\,$<:$\,U$@. Then $T$ is equivalent to the existential +Let $T = p.c[\mathit{targs},T,\mathit{targs}']$ be a parameterized type where +$\mathit{targs}, \mathit{targs}'$ may be empty and +$T$ is a wildcard type `_$\;$>:$\,L\,$<:$\,U$`. Then $T$ is equivalent to the +existential type ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -$p.c[\targs,t,\targs']$ forSome { type $t$ >: $L$ <: $U$ } +$p.c[\mathit{targs},t,\mathit{targs}']$ forSome { type $t$ >: $L$ <: $U$ } ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ where $t$ is some fresh type variable. -Wildcard types may also appear as parts of infix types -(\sref{sec:infix-types}), function types (\sref{sec:function-types}), -or tuple types (\sref{sec:tuple-types}). +Wildcard types may also appear as parts of [infix types](#infix-types) +, [function types](#function-types), +or [tuple types](#tuple-types). Their expansion is then the expansion in the equivalent parameterized type. @@ -548,24 +557,24 @@ report as the internal types of defined identifiers. ### Method Types -A method type is denoted internally as $(\Ps)U$, where $(\Ps)$ is a -sequence of parameter names and types $(p_1:T_1 \commadots p_n:T_n)$ +A method type is denoted internally as $(\mathit{Ps})U$, where $(\mathit{Ps})$ +is a sequence of parameter names and types $(p_1:T_1 , \ldots , p_n:T_n)$ for some $n \geq 0$ and $U$ is a (value or method) type. This type -represents named methods that take arguments named $p_1 \commadots p_n$ -of types $T_1 \commadots T_n$ +represents named methods that take arguments named $p_1 , \ldots , p_n$ +of types $T_1 , \ldots , T_n$ and that return a result of type $U$. -Method types associate to the right: $(\Ps_1)(\Ps_2)U$ is -treated as $(\Ps_1)((\Ps_2)U)$. +Method types associate to the right: $(\mathit{Ps}_1)(\mathit{Ps}_2)U$ is +treated as $(\mathit{Ps}_1)((\mathit{Ps}_2)U)$. A special case are types of methods without any parameters. They are -written here \lstinline@=> T@. Parameterless methods name expressions +written here `=> T`. Parameterless methods name expressions that are re-evaluated each time the parameterless method name is referenced. Method types do not exist as types of values. If a method name is used -as a value, its type is implicitly converted to a corresponding -function type (\sref{sec:impl-conv}). +as a value, its type is [implicitly converted](#implicit-conversions) to a +corresponding function type. (@) The declarations @@ -585,16 +594,15 @@ function type (\sref{sec:impl-conv}). ### Polymorphic Method Types - -A polymorphic method type is denoted internally as ~\lstinline@[$\tps\,$]$T$@~ where -\lstinline@[$\tps\,$]@ is a type parameter section -~\lstinline@[$a_1$ >: $L_1$ <: $U_1 \commadots a_n$ >: $L_n$ <: $U_n$]@~ +A polymorphic method type is denoted internally as `[$\mathit{tps}\,$]$T$` where +`[$\mathit{tps}\,$]` is a type parameter section +`[$a_1$ >: $L_1$ <: $U_1 , \ldots , a_n$ >: $L_n$ <: $U_n$]` for some $n \geq 0$ and $T$ is a (value or method) type. This type represents named methods that -take type arguments ~\lstinline@$S_1 \commadots S_n$@~ which -conform (\sref{sec:param-types}) to the lower bounds -~\lstinline@$L_1 \commadots L_n$@~ and the upper bounds -~\lstinline@$U_1 \commadots U_n$@~ and that yield results of type $T$. +take type arguments `$S_1 , \ldots , S_n$` which +[conform](#parameterized-types) to the lower bounds +`$L_1 , \ldots , L_n$` and the upper bounds +`$U_1 , \ldots , U_n$` and that yield results of type $T$. (@) The declarations @@ -613,7 +621,11 @@ conform (\sref{sec:param-types}) to the lower bounds ### Type Constructors A type constructor is represented internally much like a polymorphic method type. -~\lstinline@[$\pm$ $a_1$ >: $L_1$ <: $U_1 \commadots \pm a_n$ >: $L_n$ <: $U_n$] $T$@~ represents a type that is expected by a type constructor parameter (\sref{sec:type-params}) or an abstract type constructor binding (\sref{sec:typedcl}) with the corresponding type parameter clause. +`[$\pm$ $a_1$ >: $L_1$ <: $U_1 , \ldots , \pm a_n$ >: $L_n$ <: $U_n$] $T$` +represents a type that is expected by a +[type constructor parameter](#type-params) or an +[abstract type constructor binding](#type-declarations-and-type-aliases) with +the corresponding type parameter clause. (@) Consider this fragment of the `Iterable[+X]`{.scala} class: @@ -644,300 +656,283 @@ These notions are defined mutually recursively as follows. #. The set of _base types_ of a type is a set of class types, given as follows. - - The base types of a class type $C$ with parents $T_1 \commadots T_n$ are + - The base types of a class type $C$ with parents $T_1 , \ldots , T_n$ are $C$ itself, as well as the base types of the compound type - ~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@. + `$T_1$ with … with $T_n$ { $R$ }`. - The base types of an aliased type are the base types of its alias. - The base types of an abstract type are the base types of its upper bound. - The base types of a parameterized type - ~\lstinline@$C$[$T_1 \commadots T_n$]@~ are the base types + `$C$[$T_1 , \ldots , T_n$]` are the base types of type $C$, where every occurrence of a type parameter $a_i$ of $C$ has been replaced by the corresponding parameter type $T_i$. - - The base types of a singleton type \lstinline@$p$.type@ are the base types of + - The base types of a singleton type `$p$.type` are the base types of the type of $p$. - The base types of a compound type - ~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@~ + `$T_1$ with $\ldots$ with $T_n$ { $R$ }` are the _reduced union_ of the base classes of all $T_i$'s. This means: - Let the multi-set $\SS$ be the multi-set-union of the + Let the multi-set $\mathscr{S}$ be the multi-set-union of the base types of all $T_i$'s. - If $\SS$ contains several type instances of the same class, say - ~\lstinline@$S^i$#$C$[$T^i_1 \commadots T^i_n$]@~ $(i \in I)$, then + If $\mathscr{S}$ contains several type instances of the same class, say + `$S^i$#$C$[$T^i_1 , \ldots , T^i_n$]` $(i \in I)$, then all those instances are replaced by one of them which conforms to all - others. It is an error if no such instance exists. It follows that the reduced union, if it exists, - produces a set of class types, where different types are instances of different classes. - - The base types of a type selection \lstinline@$S$#$T$@ are + others. It is an error if no such instance exists. It follows that the + reduced union, if it exists, + produces a set of class types, where different types are instances of + different classes. + - The base types of a type selection `$S$#$T$` are determined as follows. If $T$ is an alias or abstract type, the previous clauses apply. Otherwise, $T$ must be a (possibly parameterized) class type, which is defined in some class $B$. Then - the base types of \lstinline@$S$#$T$@ are the base types of $T$ + the base types of `$S$#$T$` are the base types of $T$ in $B$ seen from the prefix type $S$. - - The base types of an existential type \lstinline@$T$ forSome {$\,Q\,$}@ are - all types \lstinline@$S$ forSome {$\,Q\,$}@ where $S$ is a base type of $T$. - -2. The notion of a type $T$ -{\em in class $C$ seen from some prefix type -$S\,$} makes sense only if the prefix type $S$ -has a type instance of class $C$ as a base type, say -~\lstinline@$S'$#$C$[$T_1 \commadots T_n$]@. Then we define as follows. -\begin{itemize} - \item - If \lstinline@$S$ = $\epsilon$.type@, then $T$ in $C$ seen from $S$ is $T$ itself. - \item - Otherwise, if $S$ is an existential type ~\lstinline@$S'$ forSome {$\,Q\,$}@, and - $T$ in $C$ seen from $S'$ is $T'$, - then $T$ in $C$ seen from $S$ is ~\lstinline@$T'$ forSome {$\,Q\,$}@. - \item - Otherwise, if $T$ is the $i$'th type parameter of some class $D$, then - \begin{itemize} - \item - If $S$ has a base type ~\lstinline@$D$[$U_1 \commadots U_n$]@, for some type parameters - ~\lstinline@[$U_1 \commadots U_n$]@, then $T$ in $C$ seen from $S$ is $U_i$. - \item - Otherwise, if $C$ is defined in a class $C'$, then - $T$ in $C$ seen from $S$ is the same as $T$ in $C'$ seen from $S'$. - \item - Otherwise, if $C$ is not defined in another class, then - $T$ in $C$ seen from $S$ is $T$ itself. - \end{itemize} -\item - Otherwise, - if $T$ is the singleton type \lstinline@$D$.this.type@ for some class $D$ - then - \begin{itemize} - \item - If $D$ is a subclass of $C$ and - $S$ has a type instance of class $D$ among its base types, - then $T$ in $C$ seen from $S$ is $S$. - \item - Otherwise, if $C$ is defined in a class $C'$, then - $T$ in $C$ seen from $S$ is the same as $T$ in $C'$ seen from $S'$. - \item - Otherwise, if $C$ is not defined in another class, then - $T$ in $C$ seen from $S$ is $T$ itself. - \end{itemize} -\item - If $T$ is some other type, then the described mapping is performed - to all its type components. -\end{itemize} - -If $T$ is a possibly parameterized class type, where $T$'s class -is defined in some other class $D$, and $S$ is some prefix type, -then we use ``$T$ seen from $S$'' as a shorthand for -``$T$ in $D$ seen from $S$''. - -3. The _member bindings_ of a type $T$ are (1) all bindings $d$ such that -there exists a type instance of some class $C$ among the base types of $T$ -and there exists a definition or declaration $d'$ in $C$ -such that $d$ results from $d'$ by replacing every -type $T'$ in $d'$ by $T'$ in $C$ seen from $T$, and (2) all bindings -of the type's refinement (\sref{sec:refinements}), if it has one. - -The _definition_ of a type projection \lstinline@$S$#$t$@ is the member -binding $d_t$ of the type $t$ in $S$. In that case, we also say -that \lstinline@$S$#$t$@ _is defined by_ $d_t$. -share a to + - The base types of an existential type `$T$ forSome { $Q$ }` are + all types `$S$ forSome { $Q$ }` where $S$ is a base type of $T$. + +#. The notion of a type $T$ _in class $C$ seen from some prefix type $S$_ + makes sense only if the prefix type $S$ + has a type instance of class $C$ as a base type, say + `$S'$#$C$[$T_1 , \ldots , T_n$]`. Then we define as follows. + - If `$S$ = $\epsilon$.type`, then $T$ in $C$ seen from $S$ is + $T$ itself. + - Otherwise, if $S$ is an existential type `$S'$ forSome { $Q$ }`, and + $T$ in $C$ seen from $S'$ is $T'$, + then $T$ in $C$ seen from $S$ is `$T'$ forSome {$\,Q\,$}`. + - Otherwise, if $T$ is the $i$'th type parameter of some class $D$, then + - If $S$ has a base type `$D$[$U_1 , \ldots , U_n$]`, for some type + parameters `[$U_1 , \ldots , U_n$]`, then $T$ in $C$ seen from $S$ + is $U_i$. + - Otherwise, if $C$ is defined in a class $C'$, then + $T$ in $C$ seen from $S$ is the same as $T$ in $C'$ seen from $S'$. + - Otherwise, if $C$ is not defined in another class, then + $T$ in $C$ seen from $S$ is $T$ itself. + - Otherwise, if $T$ is the singleton type `$D$.this.type` for some class $D$ + then + - If $D$ is a subclass of $C$ and $S$ has a type instance of class $D$ + among its base types, then $T$ in $C$ seen from $S$ is $S$. + - Otherwise, if $C$ is defined in a class $C'$, then + $T$ in $C$ seen from $S$ is the same as $T$ in $C'$ seen from $S'$. + - Otherwise, if $C$ is not defined in another class, then + $T$ in $C$ seen from $S$ is $T$ itself. + - If $T$ is some other type, then the described mapping is performed + to all its type components. + + If $T$ is a possibly parameterized class type, where $T$'s class + is defined in some other class $D$, and $S$ is some prefix type, + then we use ``$T$ seen from $S$'' as a shorthand for + ``$T$ in $D$ seen from $S$''. + +#. The _member bindings_ of a type $T$ are (1) all bindings $d$ such that + there exists a type instance of some class $C$ among the base types of $T$ + and there exists a definition or declaration $d'$ in $C$ + such that $d$ results from $d'$ by replacing every + type $T'$ in $d'$ by $T'$ in $C$ seen from $T$, and (2) all bindings + of the type's [refinement](#compound-types), if it has one. + + The _definition_ of a type projection `$S$#$t$` is the member + binding $d_t$ of the type $t$ in $S$. In that case, we also say + that ~$S$#$t$` _is defined by_ $d_t$. + share a to Relations between types ----------------------- We define two relations between types. -\begin{quote}\begin{tabular}{l@{\gap}l@{\gap}l} -\em Type equivalence & $T \equiv U$ & $T$ and $U$ are interchangeable -in all contexts. -\\ -\em Conformance & $T \conforms U$ & Type $T$ conforms to type $U$. -\end{tabular}\end{quote} + +----------------- ---------------- ------------------------------------------------- +Type equivalence $T \equiv U$ $T$ and $U$ are interchangeable in all contexts. +Conformance $T <: U$ Type $T$ conforms to type $U$. +----------------- ---------------- ------------------------------------------------- + ### Type Equivalence -\label{sec:type-equiv} - -Equivalence $(\equiv)$ between types is the smallest congruence\footnote{ A -congruence is an equivalence relation which is closed under formation -of contexts} such that the following holds: -\begin{itemize} -\item -If $t$ is defined by a type alias ~\lstinline@type $t$ = $T$@, then $t$ is -equivalent to $T$. -\item -If a path $p$ has a singleton type ~\lstinline@$q$.type@, then -~\lstinline@$p$.type $\equiv q$.type@. -\item -If $O$ is defined by an object definition, and $p$ is a path -consisting only of package or object selectors and ending in $O$, then -~\lstinline@$O$.this.type $\equiv p$.type@. -\item -Two compound types (\sref{sec:compound-types}) are equivalent if the sequences of their component -are pairwise equivalent, and occur in the same order, and their -refinements are equivalent. Two refinements are equivalent if they -bind the same names and the modifiers, types and bounds of every -declared entity are equivalent in both refinements. -\item -Two method types (\sref{sec:method-types}) are equivalent if they have equivalent result types, -both have the same number of parameters, and corresponding parameters -have equivalent types. Note that the names of parameters do not -matter for method type equivalence. -\item -Two polymorphic method types (\sref{sec:poly-types}) are equivalent if they have the same number of -type parameters, and, after renaming one set of type parameters by -another, the result types as well as lower and upper bounds of -corresponding type parameters are equivalent. -\item -Two existential types (\sref{sec:existential-types}) -are equivalent if they have the same number of -quantifiers, and, after renaming one list of type quantifiers by -another, the quantified types as well as lower and upper bounds of -corresponding quantifiers are equivalent. -\item %@M -Two type constructors (\sref{sec:higherkinded-types}) are equivalent if they have the -same number of type parameters, and, after renaming one list of type parameters by -another, the result types as well as variances, lower and upper bounds of -corresponding type parameters are equivalent. -\end{itemize} + +Equivalence $(\equiv)$ between types is the smallest congruence [^3] such that +the following holds: + +- If $t$ is defined by a type alias `type $t$ = $T$`, then $t$ is + equivalent to $T$. +- If a path $p$ has a singleton type `$q$.type`, then + `$p$.type $\equiv q$.type`. +- If $O$ is defined by an object definition, and $p$ is a path + consisting only of package or object selectors and ending in $O$, then + `$O$.this.type $\equiv p$.type`. +- Two [compound types](#compound-types) are equivalent if the sequences + of their component are pairwise equivalent, and occur in the same order, and + their refinements are equivalent. Two refinements are equivalent if they + bind the same names and the modifiers, types and bounds of every + declared entity are equivalent in both refinements. +- Two [method types](#method-types) are equivalent if they have + equivalent result types, + both have the same number of parameters, and corresponding parameters + have equivalent types. Note that the names of parameters do not + matter for method type equivalence. +- Two [polymorphic method types](#polymorphic-method-types) are equivalent if + they have the same number of type parameters, and, after renaming one set of + type parameters by another, the result types as well as lower and upper bounds + of corresponding type parameters are equivalent. +- Two [existential types](#existential-types) + are equivalent if they have the same number of + quantifiers, and, after renaming one list of type quantifiers by + another, the quantified types as well as lower and upper bounds of + corresponding quantifiers are equivalent. +- Two [type constructors](#type-constructors) are equivalent if they have the + same number of type parameters, and, after renaming one list of type + parameters by another, the result types as well as variances, lower and upper + bounds of corresponding type parameters are equivalent. + + +[^3]: A congruence is an equivalence relation which is closed under formation +of contexts + ### Conformance -\label{sec:conformance} -The conformance relation $(\conforms)$ is the smallest +The conformance relation $(<:)$ is the smallest transitive relation that satisfies the following conditions. -\begin{itemize} -\item Conformance includes equivalence. If $T \equiv U$ then $T \conforms U$. -\item For every value type $T$, - $\mbox{\code{scala.Nothing}} \conforms T \conforms \mbox{\code{scala.Any}}$. -\item For every type constructor $T$ (with any number of type parameters), - $\mbox{\code{scala.Nothing}} \conforms T \conforms \mbox{\code{scala.Any}}$. %@M + +- Conformance includes equivalence. If $T \equiv U$ then $T <: U$. +- For every value type $T$, `scala.Nothing <: $T$ <: scala.Any`. +- For every type constructor $T$ (with any number of type parameters), + `scala.Nothing <: $T$ <: scala.Any`. -\item For every class type $T$ such that $T \conforms - \mbox{\code{scala.AnyRef}}$ and not $T \conforms \mbox{\code{scala.NotNull}}$ - one has $\mbox{\code{scala.Null}} \conforms T$. -\item A type variable or abstract type $t$ conforms to its upper bound and - its lower bound conforms to $t$. -\item A class type or parameterized type conforms to any of its - base-types. -\item A singleton type \lstinline@$p$.type@ conforms to the type of - the path $p$. -\item A singleton type \lstinline@$p$.type@ conforms to the type $\mbox{\code{scala.Singleton}}$. -\item A type projection \lstinline@$T$#$t$@ conforms to \lstinline@$U$#$t$@ if - $T$ conforms to $U$. -\item A parameterized type ~\lstinline@$T$[$T_1 \commadots T_n$]@~ conforms to - ~\lstinline@$T$[$U_1 \commadots U_n$]@~ if - the following three conditions hold for $i = 1 \commadots n$. - \begin{itemize} - \item - If the $i$'th type parameter of $T$ is declared covariant, then $T_i \conforms U_i$. - \item - If the $i$'th type parameter of $T$ is declared contravariant, then $U_i \conforms T_i$. - \item - If the $i$'th type parameter of $T$ is declared neither covariant - nor contravariant, then $U_i \equiv T_i$. - \end{itemize} -\item A compound type ~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@~ conforms to - each of its component types $T_i$. -\item If $T \conforms U_i$ for $i = 1 \commadots n$ and for every - binding $d$ of a type or value $x$ in $R$ there exists a member - binding of $x$ in $T$ which subsumes $d$, then $T$ conforms to the - compound type ~\lstinline@$U_1$ with $\ldots$ with $U_n$ {$R\,$}@. -\item The existential type ~\lstinline@$T$ forSome {$\,Q\,$}@ conforms to - $U$ if its skolemization (\sref{sec:existential-types}) - conforms to $U$. -\item The type $T$ conforms to the existential type ~\lstinline@$U$ forSome {$\,Q\,$}@ - if $T$ conforms to one of the type instances (\sref{sec:existential-types}) - of ~\lstinline@$U$ forSome {$\,Q\,$}@. -\item If - $T_i \equiv T'_i$ for $i = 1 \commadots n$ and $U$ conforms to $U'$ - then the method type $(p_1:T_1 \commadots p_n:T_n) U$ conforms to - $(p'_1:T'_1 \commadots p'_n:T'_n) U'$. -\item The polymorphic type -$[a_1 >: L_1 <: U_1 \commadots a_n >: L_n <: U_n] T$ conforms to the polymorphic type -$[a_1 >: L'_1 <: U'_1 \commadots a_n >: L'_n <: U'_n] T'$ if, assuming -$L'_1 \conforms a_1 \conforms U'_1 \commadots L'_n \conforms a_n \conforms U'_n$ -one has $T \conforms T'$ and $L_i \conforms L'_i$ and $U'_i \conforms U_i$ -for $i = 1 \commadots n$. -%@M -\item Type constructors $T$ and $T'$ follow a similar discipline. We characterize $T$ and $T'$ by their type parameter clauses -$[a_1 \commadots a_n]$ and -$[a'_1 \commadots a'_n ]$, where an $a_i$ or $a'_i$ may include a variance annotation, a higher-order type parameter clause, and bounds. Then, $T$ conforms to $T'$ if any list $[t_1 \commadots t_n]$ -- with declared variances, bounds and higher-order type parameter clauses -- of valid type arguments for $T'$ is also a valid list of type arguments for $T$ and $T[t_1 \commadots t_n] \conforms T'[t_1 \commadots t_n]$. Note that this entails that: - \begin{itemize} - \item - The bounds on $a_i$ must be weaker than the corresponding bounds declared for $a'_i$. - \item - The variance of $a_i$ must match the variance of $a'_i$, where covariance matches covariance, contravariance matches contravariance and any variance matches invariance. - \item - Recursively, these restrictions apply to the corresponding higher-order type parameter clauses of $a_i$ and $a'_i$. - \end{itemize} - -\end{itemize} +- For every class type $T$ such that `$T$ <: scala.AnyRef` and not + `$T$ <: scala.NotNull` one has `scala.Null <: $T$`. +- A type variable or abstract type $t$ conforms to its upper bound and + its lower bound conforms to $t$. +- A class type or parameterized type conforms to any of its base-types. +- A singleton type `$p$.type` conforms to the type of the path $p$. +- A singleton type `$p$.type` conforms to the type `scala.Singleton`. +- A type projection `$T$#$t$` conforms to `$U$#$t$` if $T$ conforms to $U$. +- A parameterized type `$T$[$T_1$ , … , $T_n$]` conforms to + `$T$[$U_1$ , … , $U_n$]` if + the following three conditions hold for $i \in \{ 1 , \ldots , n \}$: + #. If the $i$'th type parameter of $T$ is declared covariant, then + $T_i <: U_i$. + #. If the $i$'th type parameter of $T$ is declared contravariant, then + $U_i <: T_i$. + #. If the $i$'th type parameter of $T$ is declared neither covariant + nor contravariant, then $U_i \equiv T_i$. +- A compound type `$T_1$ with $\ldots$ with $T_n$ {$R\,$}` conforms to + each of its component types $T_i$. +- If $T <: U_i$ for $i \in \{ 1 , \ldots , n \}$ and for every + binding $d$ of a type or value $x$ in $R$ there exists a member + binding of $x$ in $T$ which subsumes $d$, then $T$ conforms to the + compound type `$U_1$ with $\ldots$ with $U_n$ {$R\,$}`. +- The existential type `$T$ forSome {$\,Q\,$}` conforms to + $U$ if its [skolemization](#existential-types) + conforms to $U$. +- The type $T$ conforms to the existential type `$U$ forSome {$\,Q\,$}` + if $T$ conforms to one of the [type instances](#existential-types) + of `$U$ forSome {$\,Q\,$}`. +- If + $T_i \equiv T'_i$ for $i \in \{ 1 , \ldots , n\}$ and $U$ conforms to $U'$ + then the method type $(p_1:T_1 , \ldots , p_n:T_n) U$ conforms to + $(p'_1:T'_1 , \ldots , p'_n:T'_n) U'$. +- The polymorphic type + $[a_1 >: L_1 <: U_1 , \ldots , a_n >: L_n <: U_n] T$ conforms to the + polymorphic type + $[a_1 >: L'_1 <: U'_1 , \ldots , a_n >: L'_n <: U'_n] T'$ if, assuming + $L'_1 <: a_1 <: U'_1 , \ldots , L'_n <: a_n <: U'_n$ + one has $T <: T'$ and $L_i <: L'_i$ and $U'_i <: U_i$ + for $i \in \{ 1 , \ldots , n \}$. +- Type constructors $T$ and $T'$ follow a similar discipline. We characterize + $T$ and $T'$ by their type parameter clauses + $[a_1 , \ldots , a_n]$ and + $[a'_1 , \ldots , a'_n ]$, where an $a_i$ or $a'_i$ may include a variance + annotation, a higher-order type parameter clause, and bounds. Then, $T$ + conforms to $T'$ if any list $[t_1 , \ldots , t_n]$ -- with declared + variances, bounds and higher-order type parameter clauses -- of valid type + arguments for $T'$ is also a valid list of type arguments for $T$ and + $T[t_1 , \ldots , t_n] <: T'[t_1 , \ldots , t_n]$. Note that this entails + that: + - The bounds on $a_i$ must be weaker than the corresponding bounds declared + for $a'_i$. + - The variance of $a_i$ must match the variance of $a'_i$, where covariance + matches covariance, contravariance matches contravariance and any variance + matches invariance. + - Recursively, these restrictions apply to the corresponding higher-order + type parameter clauses of $a_i$ and $a'_i$. + A declaration or definition in some compound type of class type $C$ -_subsumes_ another -declaration of the same name in some compound type or class type $C'$, if one of the following holds. -\begin{itemize} -\item -A value declaration or definition that defines a name $x$ with type $T$ subsumes -a value or method declaration that defines $x$ with type $T'$, provided $T \conforms T'$. -\item -A method declaration or definition that defines a name $x$ with type $T$ subsumes -a method declaration that defines $x$ with type $T'$, provided $T \conforms T'$. -\item -A type alias -$\TYPE;t[T_1 \commadots T_n]=T$ subsumes a type alias $\TYPE;t[T_1 \commadots T_n]=T'$ if %@M -$T \equiv T'$. -\item -A type declaration ~\lstinline@type $t$[$T_1 \commadots T_n$] >: $L$ <: $U$@~ subsumes %@M -a type declaration ~\lstinline@type $t$[$T_1 \commadots T_n$] >: $L'$ <: $U'$@~ if $L' \conforms L$ and %@M -$U \conforms U'$. -\item -A type or class definition that binds a type name $t$ subsumes an abstract -type declaration ~\lstinline@type t[$T_1 \commadots T_n$] >: L <: U@~ if %@M -$L \conforms t \conforms U$. -\end{itemize} - -The $(\conforms)$ relation forms pre-order between types, -i.e.\ it is transitive and reflexive. _least upper bounds_ and _greatest lower bounds_ of a set of types +_subsumes_ another declaration of the same name in some compound type or class +type $C'$, if one of the following holds. + +- A value declaration or definition that defines a name $x$ with type $T$ + subsumes + a value or method declaration that defines $x$ with type $T'$, provided + $T <: T'$. +- A method declaration or definition that defines a name $x$ with type $T$ + subsumes a method declaration that defines $x$ with type $T'$, provided + $T <: T'$. +- A type alias + `type $t$[$T_1$ , … , $T_n$] = $T$` subsumes a type alias + `type $t$[$T_1$ , … , $T_n$] = $T'$` if $T \equiv T'$. +- A type declaration `type $t$[$T_1$ , … , $T_n$] >: $L$ <: $U$` subsumes + a type declaration `type $t$[$T_1$ , … , $T_n$] >: $L'$ <: $U'$` if + $L' <: L$ and $U <: U'$. +- A type or class definition that binds a type name $t$ subsumes an abstract + type declaration `type t[$T_1$ , … , $T_n$] >: L <: U` if + $L <: t <: U$. + + +The $(<:)$ relation forms pre-order between types, +i.e.\ it is transitive and reflexive. _least upper bounds_ and +_greatest lower bounds_ of a set of types are understood to be relative to that order. -\paragraph{Note} The least upper bound or greatest lower bound -of a set of types does not always exist. For instance, consider -the class definitions -\begin{lstlisting} + +> **Note**: The least upper bound or greatest lower bound +> of a set of types does not always exist. For instance, consider +> the class definitions + +~~~~~~~~~~~~~~~~~~~~~ {.scala} class A[+T] {} -class B extends A[B] -class C extends A[C] -\end{lstlisting} -Then the types ~\lstinline@A[Any], A[A[Any]], A[A[A[Any]]], ...@~ form -a descending sequence of upper bounds for \code{B} and \code{C}. The -least upper bound would be the infinite limit of that sequence, which -does not exist as a Scala type. Since cases like this are in general -impossible to detect, a Scala compiler is free to reject a term -which has a type specified as a least upper or greatest lower bound, -and that bound would be more complex than some compiler-set -limit\footnote{The current Scala compiler limits the nesting level -of parameterization in such bounds to be at most two deeper than the maximum -nesting level of the operand types}. - -The least upper bound or greatest lower bound might also not be -unique. For instance \code{A with B} and \code{B with A} are both -greatest lower of \code{A} and \code{B}. If there are several -least upper bounds or greatest lower bounds, the Scala compiler is -free to pick any one of them. +class B extends A[B] +class C extends A[C] +~~~~~~~~~~~~~~~~~~~~~ + +> Then the types `A[Any], A[A[Any]], A[A[A[Any]]], ...` form +> a descending sequence of upper bounds for `B` and `C`. The +> least upper bound would be the infinite limit of that sequence, which +> does not exist as a Scala type. Since cases like this are in general +> impossible to detect, a Scala compiler is free to reject a term +> which has a type specified as a least upper or greatest lower bound, +> and that bound would be more complex than some compiler-set +> limit [^4]. +> +> The least upper bound or greatest lower bound might also not be +> unique. For instance `A with B` and `B with A` are both +> greatest lower of `A` and `B`. If there are several +> least upper bounds or greatest lower bounds, the Scala compiler is +> free to pick any one of them. + + +[^4]: The current Scala compiler limits the nesting level + of parameterization in such bounds to be at most two deeper than the + maximum nesting level of the operand types + + ### Weak Conformance -In some situations Scala uses a more genral conformance relation. A +In some situations Scala uses a more general conformance relation. A type $S$ _weakly conforms_ -to a type $T$, written $S \conforms_w -T$, if $S \conforms T$ or both $S$ and $T$ are primitive number types +to a type $T$, written $S <:_w +T$, if $S <: T$ or both $S$ and $T$ are primitive number types and $S$ precedes $T$ in the following ordering. -\begin{lstlisting} -Byte $\conforms_w$ Short -Short $\conforms_w$ Int -Char $\conforms_w$ Int -Int $\conforms_w$ Long -Long $\conforms_w$ Float -Float $\conforms_w$ Double -\end{lstlisting} + +~~~~~~~~~~~~~~~~~~~~ +Byte $<:_w$ Short +Short $<:_w$ Int +Char $<:_w$ Int +Int $<:_w$ Long +Long $<:_w$ Float +Float $<:_w$ Double +~~~~~~~~~~~~~~~~~~~~ A _weak least upper bound_ is a least upper bound with respect to weak conformance. @@ -946,23 +941,21 @@ weak conformance. Volatile Types -------------- - - -Type volatility approximates the possibility that a type parameter or abstract type instance -of a type does not have any non-null values. As explained in -(\sref{sec:paths}), a value member of a volatile type cannot appear in -a path. +Type volatility approximates the possibility that a type parameter or abstract +type instance +of a type does not have any non-null values. A value member of a volatile type +cannot appear in a [path](#paths). A type is _volatile_ if it falls into one of four categories: -A compound type ~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@~ +A compound type `$T_1$ with … with $T_n$ {$R\,$}` is volatile if one of the following two conditions hold. -#. One of $T_2 \commadots T_n$ is a type parameter or abstract type, or +#. One of $T_2 , \ldots , T_n$ is a type parameter or abstract type, or #. $T_1$ is an abstract type and and either the refinement $R$ or a type $T_j$ for $j > 1$ contributes an abstract member to the compound type, or -#. one of $T_1 \commadots T_n$ is a singleton type. +#. one of $T_1 , \ldots , T_n$ is a singleton type. Here, a type $S$ _contributes an abstract member_ to a type $T$ if @@ -971,13 +964,13 @@ A refinement $R$ contributes an abstract member to a type $T$ if $R$ contains an abstract declaration which is also a member of $T$. A type designator is volatile if it is an alias of a volatile type, or -if it designates a type parameter or abstract type that has a volatile type as its -upper bound. +if it designates a type parameter or abstract type that has a volatile type as +its upper bound. -A singleton type \lstinline@$p$.type@ is volatile, if the underlying +A singleton type `$p$.type` is volatile, if the underlying type of path $p$ is volatile. -An existential type ~\lstinline@$T$ forSome {$\,Q\,$}@~ is volatile if +An existential type `$T$ forSome {$\,Q\,$}` is volatile if $T$ is volatile. @@ -989,25 +982,25 @@ _Type erasure_ is a mapping from (possibly generic) types to non-generic types. We write $|T|$ for the erasure of type $T$. The erasure mapping is defined as follows. -- The erasure of an alias type is the erasure of its right-hand side. %@M +- The erasure of an alias type is the erasure of its right-hand side. - The erasure of an abstract type is the erasure of its upper bound. -- The erasure of the parameterized type \lstinline@scala.Array$[T_1]$@ is - \lstinline@scala.Array$[|T_1|]$@. -- The erasure of every other parameterized type $T[T_1 \commadots T_n]$ is $|T|$. -- The erasure of a singleton type \lstinline@$p$.type@ is the +- The erasure of the parameterized type `scala.Array$[T_1]$` is + `scala.Array$[|T_1|]$`. +- The erasure of every other parameterized type $T[T_1 , \ldots , T_n]$ is $|T|$. +- The erasure of a singleton type `$p$.type` is the erasure of the type of $p$. -- The erasure of a type projection \lstinline@$T$#$x$@ is \lstinline@|$T$|#$x$@. +- The erasure of a type projection `$T$#$x$` is `|$T$|#$x$`. - The erasure of a compound type - ~\lstinline@$T_1$ with $\ldots$ with $T_n$ {$R\,$}@ is the erasure of the intersection dominator of - $T_1 \commadots T_n$. -- The erasure of an existential type ~\lstinline@$T$ forSome {$\,Q\,$}@ - is $|T|$. - -The _intersection dominator_ of a list of types $T_1 \commadots -T_n$ is computed as follows. -Let $T_{i_1} \commadots T_{i_m}$ be the subsequence of types $T_i$ + `$T_1$ with $\ldots$ with $T_n$ {$R\,$}` is the erasure of the intersection + dominator of $T_1 , \ldots , T_n$. +- The erasure of an existential type `$T$ forSome {$\,Q\,$}` is $|T|$. + +The _intersection dominator_ of a list of types $T_1 , \ldots , T_n$ is computed +as follows. +Let $T_{i_1} , \ldots , T_{i_m}$ be the subsequence of types $T_i$ which are not supertypes of some other type $T_j$. -If this subsequence contains a type designator $T_c$ that refers to a class which is not a trait, +If this subsequence contains a type designator $T_c$ that refers to a class +which is not a trait, the intersection dominator is $T_c$. Otherwise, the intersection dominator is the first element of the subsequence, $T_{i_1}$. diff --git a/16-references.md b/16-references.md new file mode 100644 index 000000000000..c0a3338641c7 --- /dev/null +++ b/16-references.md @@ -0,0 +1,6 @@ +References +========== + + \ No newline at end of file diff --git a/README.md b/README.md index dcdaf3a250ae..5370411ba714 100644 --- a/README.md +++ b/README.md @@ -62,6 +62,14 @@ code fragment. ### Macro replacements: +- While MathJAX just support LaTeX style command definition, it is recommended + to not use this as it will likely cause issues with preparing the document + for PDF or ebook distribution. +- `\SS` (which I could not find defined within the latex source) seems to be + closest to `\mathscr{S}` +- `\TYPE` is equivalent to `\boldsymbol{type}' +- As MathJAX has no support for slanted font (latex command \sl), so in all + instances this should be replaced with \mathit{} - The macro \U{ABCD} used for unicode character references can be replaced with \\uABCD. - The macro \URange{ABCD}{DCBA} used for unicode character ranges can be @@ -92,4 +100,11 @@ syntax #. first entry #. ... - #. last entry \ No newline at end of file + #. last entry + + +Finding rendering errors +------------------------ + +- MathJAX errors will appear within the rendered DOM as span elements with + class `mtext` and style attribute `color: red` applied. \ No newline at end of file diff --git a/build.sh b/build.sh index 541256d46868..6d17afaa7081 100755 --- a/build.sh +++ b/build.sh @@ -4,7 +4,8 @@ cat 01-title.md \ 02-preface.md \ 03-lexical-syntax.md \ 04-identifiers-names-and-scopes.md \ - 05-types.md > build/ScalaReference.md + 05-types.md \ + 16-references.md > build/ScalaReference.md # 06-basic-declarations-and-definitions.md \ # 07-classes-and-objects.md \ # 08-expressions.md \ @@ -24,7 +25,7 @@ pandoc -f markdown \ --number-sections \ --bibliography=Scala.bib \ --template=resources/scala-ref-template.html5 \ - --mathjax \ + --mathjax='http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML' \ -o build/ScalaReference.html \ build/ScalaReference.md diff --git a/resources/ScalaReference.js b/resources/ScalaReference.js new file mode 100644 index 000000000000..51be0cf05b38 --- /dev/null +++ b/resources/ScalaReference.js @@ -0,0 +1,20 @@ +$(function() { + + var popoutTOC = $('
'); + popoutTOC.attr('id', 'popoutTOC'); + + var popoutTOChead = $('Jump to...'); + popoutTOChead.appendTo(popoutTOC); + + var content = $('
'); + $('#TOC > *').clone().appendTo(content); + content.appendTo(popoutTOC); + var enter = function() { content.css('display', 'block') }; + var exit = function() { content.css('display', 'none') }; + + popoutTOC.hover(enter, exit); + + // disabled for now, until better styled + // popoutTOC.appendTo($('body')); + +}) \ No newline at end of file diff --git a/resources/scala-ref-template.html5 b/resources/scala-ref-template.html5 index 424170d3d876..526543d69c39 100644 --- a/resources/scala-ref-template.html5 +++ b/resources/scala-ref-template.html5 @@ -26,6 +26,8 @@ $endif$ $for(css)$ $endfor$ + + From c61f554acd65885cedee8ebae2bfaf2c9d70275a Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 25 Mar 2014 16:35:28 -0700 Subject: [PATCH 149/826] fix indentation for footnotes --- 05-types.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/05-types.md b/05-types.md index 1e7e42242249..e544d01eb4a8 100644 --- a/05-types.md +++ b/05-types.md @@ -291,8 +291,8 @@ one of the component types $T_1 , \ldots , T_n$, the usual rules for or definition is said to be “structural” [^2]. [^2]: A reference to a structurally defined member (method call or access -to a value or variable) may generate binary code that is significantly -slower than an equivalent code to a non-structural member. + to a value or variable) may generate binary code that is significantly + slower than an equivalent code to a non-structural member. Within a method declaration in a structural refinement, the type of any value parameter may only refer to type parameters or abstract From a1275c4cb6fbc7483c0064a072f8cb3dbf7193d4 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 25 Mar 2014 16:35:37 -0700 Subject: [PATCH 150/826] TODO: binding example --- 04-identifiers-names-and-scopes.md | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/04-identifiers-names-and-scopes.md b/04-identifiers-names-and-scopes.md index 57af8afc3e6a..3086525634e3 100644 --- a/04-identifiers-names-and-scopes.md +++ b/04-identifiers-names-and-scopes.md @@ -34,18 +34,21 @@ in some inner scope _shadows_ bindings of lower precedence in the same scope as well as bindings of the same or lower precedence in outer scopes. + A reference to an unqualified (type- or term-) identifier $x$ is bound by the unique binding, which From 617bdf852c7685677650727c0534d7d4297718f1 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Wed, 26 Mar 2014 00:42:24 -0700 Subject: [PATCH 151/826] mathjax escape dollar --- _layouts/default.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/_layouts/default.yml b/_layouts/default.yml index 0081c2000bb3..1f309ef0d6e5 100644 --- a/_layouts/default.yml +++ b/_layouts/default.yml @@ -6,7 +6,8 @@ MathJax.Hub.Config({ tex2jax: { inlineMath: [['$','$'], ['\\(','\\)']], - skipTags: ['script', 'noscript', 'style', 'textarea'] + skipTags: ['script', 'noscript', 'style', 'textarea'], + processEscapes: true } }); From 7307a03e5456b0c260435f61354917e8b769a5bb Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Wed, 26 Mar 2014 00:42:37 -0700 Subject: [PATCH 152/826] TODO: number headings using css --- _layouts/default.yml | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/_layouts/default.yml b/_layouts/default.yml index 1f309ef0d6e5..8eef38c95933 100644 --- a/_layouts/default.yml +++ b/_layouts/default.yml @@ -14,6 +14,20 @@ + - .highlight pre { - background-color: #f8f8f8; - border: 1px solid #cccccc; - font-size: 13px; - line-height: 19px; - overflow: auto; - padding: 6px 10px; - border-radius: 3px; } + + - pre { - background-color: #f8f8f8; - border: 1px solid #cccccc; - font-size: 13px; - line-height: 19px; - overflow: auto; - padding: 6px 10px; - border-radius: 3px; } - pre code, pre tt { - background-color: transparent; - border: none; } - - diff --git a/resources/github.css b/resources/github.css new file mode 100644 index 000000000000..bf8df4bb0307 --- /dev/null +++ b/resources/github.css @@ -0,0 +1,349 @@ +body { + font-family: Helvetica, arial, sans-serif; + font-size: 14px; + line-height: 1.6; + padding-top: 10px; + padding-bottom: 10px; + background-color: white; + padding: 30px; +} + +body > *:first-child { + margin-top: 0 !important; +} +body > *:last-child { + margin-bottom: 0 !important; +} + +a { + color: #4183C4; +} +a.absent { + color: #cc0000; +} +a.anchor { + display: block; + padding-left: 30px; + margin-left: -30px; + cursor: pointer; + position: absolute; + top: 0; + left: 0; + bottom: 0; +} + +h1, h2, h3, h4, h5, h6 { + margin: 20px 0 10px; + padding: 0; + font-weight: bold; + -webkit-font-smoothing: antialiased; + cursor: text; + position: relative; +} + +h1:hover a.anchor, h2:hover a.anchor, h3:hover a.anchor, h4:hover a.anchor, h5:hover a.anchor, h6:hover a.anchor { + background: url("../../images/modules/styleguide/para.png") no-repeat 10px center; + text-decoration: none; +} + +h1 tt, h1 code { + font-size: inherit; +} + +h2 tt, h2 code { + font-size: inherit; +} + +h3 tt, h3 code { + font-size: inherit; +} + +h4 tt, h4 code { + font-size: inherit; +} + +h5 tt, h5 code { + font-size: inherit; +} + +h6 tt, h6 code { + font-size: inherit; +} + +h1 { + font-size: 28px; + color: black; +} + +h2 { + font-size: 24px; + border-bottom: 1px solid #cccccc; + color: black; +} + +h3 { + font-size: 18px; +} + +h4 { + font-size: 16px; +} + +h5 { + font-size: 14px; +} + +h6 { + color: #777777; + font-size: 14px; +} + +p, blockquote, ul, ol, dl, li, table, pre { + margin: 15px 0; +} + + + +hr { + background: transparent url("../../images/modules/pulls/dirty-shade.png") repeat-x 0 0; + border: 0 none; + color: #cccccc; + height: 4px; + padding: 0; +} + +body > h2:first-child { + margin-top: 0; + padding-top: 0; +} +body > h1:first-child { + margin-top: 0; + padding-top: 0; +} +body > h1:first-child + h2 { + margin-top: 0; + padding-top: 0; +} +body > h3:first-child, body > h4:first-child, body > h5:first-child, body > h6:first-child { + margin-top: 0; + padding-top: 0; +} + +a:first-child h1, a:first-child h2, a:first-child h3, a:first-child h4, a:first-child h5, a:first-child h6 { + margin-top: 0; + padding-top: 0; +} + +h1 p, h2 p, h3 p, h4 p, h5 p, h6 p { + margin-top: 0; +} + +li p.first { + display: inline-block; +} + +ul, ol { + padding-left: 30px; +} + +ul :first-child, ol :first-child { + margin-top: 0; +} + +ul :last-child, ol :last-child { + margin-bottom: 0; +} + +dl { + padding: 0; +} +dl dt { + font-size: 14px; + font-weight: bold; + font-style: italic; + padding: 0; + margin: 15px 0 5px; +} +dl dt:first-child { + padding: 0; +} +dl dt > :first-child { + margin-top: 0; +} +dl dt > :last-child { + margin-bottom: 0; +} +dl dd { + margin: 0 0 15px; + padding: 0 15px; +} +dl dd > :first-child { + margin-top: 0; +} +dl dd > :last-child { + margin-bottom: 0; +} + +blockquote { + border-left: 4px solid #dddddd; + padding: 0 15px; + color: #777777; +} +blockquote > :first-child { + margin-top: 0; +} +blockquote > :last-child { + margin-bottom: 0; +} + +table { + padding: 0; +} +table tr { + border-top: 1px solid #cccccc; + background-color: white; + margin: 0; + padding: 0; +} +table tr:nth-child(2n) { + background-color: #f8f8f8; +} +table tr th { + font-weight: bold; + border: 1px solid #cccccc; + text-align: left; + margin: 0; + padding: 6px 13px; +} +table tr td { + border: 1px solid #cccccc; + text-align: left; + margin: 0; + padding: 6px 13px; +} +table tr th :first-child, table tr td :first-child { + margin-top: 0; +} +table tr th :last-child, table tr td :last-child { + margin-bottom: 0; +} + +img { + max-width: 100%; +} + +span.frame { + display: block; + overflow: hidden; +} +span.frame > span { + border: 1px solid #dddddd; + display: block; + float: left; + overflow: hidden; + margin: 13px 0 0; + padding: 7px; + width: auto; +} +span.frame span img { + display: block; + float: left; +} +span.frame span span { + clear: both; + color: #333333; + display: block; + padding: 5px 0 0; +} +span.align-center { + display: block; + overflow: hidden; + clear: both; +} +span.align-center > span { + display: block; + overflow: hidden; + margin: 13px auto 0; + text-align: center; +} +span.align-center span img { + margin: 0 auto; + text-align: center; +} +span.align-right { + display: block; + overflow: hidden; + clear: both; +} +span.align-right > span { + display: block; + overflow: hidden; + margin: 13px 0 0; + text-align: right; +} +span.align-right span img { + margin: 0; + text-align: right; +} +span.float-left { + display: block; + margin-right: 13px; + overflow: hidden; + float: left; +} +span.float-left span { + margin: 13px 0 0; +} +span.float-right { + display: block; + margin-left: 13px; + overflow: hidden; + float: right; +} +span.float-right > span { + display: block; + overflow: hidden; + margin: 13px auto 0; + text-align: right; +} + +code, tt { + margin: 0 2px; + padding: 0 5px; + white-space: nowrap; + border: 1px solid #eaeaea; + background-color: #f8f8f8; + border-radius: 3px; +} + +pre code { + margin: 0; + padding: 0; + white-space: pre; + border: none; + background: transparent; +} + +.highlight pre { + background-color: #f8f8f8; + border: 1px solid #cccccc; + font-size: 13px; + line-height: 19px; + overflow: auto; + padding: 6px 10px; + border-radius: 3px; +} +pre { + background-color: #f8f8f8; + border: 1px solid #cccccc; + font-size: 13px; + line-height: 19px; + overflow: auto; + padding: 6px 10px; + border-radius: 3px; +} +pre code, pre tt { + background-color: transparent; + border: none; +} + From 71c1716ae4f16a05825695a33d480ac194c5ae09 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Wed, 26 Mar 2014 21:40:02 -0700 Subject: [PATCH 162/826] Add language to code blocks. Shorter Example title. --- 03-lexical-syntax.md | 102 ++++++++-------- 04-identifiers-names-and-scopes.md | 8 +- 05-types.md | 86 ++++++------- 06-basic-declarations-and-definitions.md | 94 +++++++-------- 07-classes-and-objects.md | 96 +++++++-------- 08-expressions.md | 146 +++++++++++------------ 09-implicit-parameters-and-views.md | 46 +++---- 10-pattern-matching.md | 66 +++++----- 11-top-level-definitions.md | 24 ++-- 12-xml-expressions-and-patterns.md | 12 +- 13-user-defined-annotations.md | 4 +- 14-the-scala-standard-library.md | 40 +++---- 15-syntax-summary.md | 6 +- _includes/numbering.css | 4 +- _layouts/default.yml | 2 +- 15 files changed, 367 insertions(+), 369 deletions(-) diff --git a/03-lexical-syntax.md b/03-lexical-syntax.md index 503445da3f8f..c1b4d7f4ba80 100644 --- a/03-lexical-syntax.md +++ b/03-lexical-syntax.md @@ -16,7 +16,7 @@ to _Scala mode_, and literal characters `‘c’` refer to the ASCII fragment `\ In Scala mode, _Unicode escapes_ are replaced by the corresponding Unicode character with the given hexadecimal code. -``` +```ebnf UnicodeEscape ::= ‘\‘ ‘u‘ {‘u‘} hexDigit hexDigit hexDigit hexDigit hexDigit ::= ‘0’ | … | ‘9’ | ‘A’ | … | ‘F’ | ‘a’ | … | ‘f’ ``` @@ -45,7 +45,7 @@ classes (Unicode general category given in parentheses): ## Identifiers -``` +```ebnf op ::= opchar {opchar} varid ::= lower idrest plainid ::= upper idrest @@ -70,7 +70,7 @@ of all characters excluding the backquotes themselves. As usual, a longest match rule applies. For instance, the string -``` +```scala big_bob++=`def` ``` @@ -85,7 +85,7 @@ User programs should not define identifiers which contain `‘$’` characters. The following names are reserved words instead of being members of the syntactic class `id` of lexical identifiers. -``` +```scala abstract case catch class def do else extends false final finally for forSome if implicit @@ -100,15 +100,15 @@ _ : = => <- <: <% >: # @ The Unicode operators `\u21D2 $\Rightarrow$` and `\u2190 $\leftarrow$`, which have the ASCII equivalents `=>` and `<-`, are also reserved. -### Example: +### Example -``` +```scala x Object maxIndex p2p empty_? + `yield` αρετη _y dot_product_* __system _MAX_LEN_ ``` -### Example: +### Example When one needs to access Java identifiers that are reserved words in Scala, use backquote-enclosed strings. For instance, the statement `Thread.yield()` is illegal, since `yield` is a reserved word in Scala. However, here's a @@ -117,7 +117,7 @@ work-around: `` Thread.`yield`() `` ## Newline Characters -``` +```ebnf semi ::= ‘;’ | nl {nl} ``` @@ -132,7 +132,7 @@ as the special token “nl” if the three following criteria are satisfied: The tokens that can terminate a statement are: literals, identifiers and the following delimiters and reserved words: -``` +```scala this null true false return type _ ) ] } ``` @@ -140,7 +140,7 @@ _ ) ] } The tokens that can begin a statement are all Scala tokens _except_ the following delimiters and reserved words: -``` +```scala catch else extends finally forSome match with yield , . ; : = => <- <: <% >: # [ ) ] } @@ -207,12 +207,12 @@ A single new line token is accepted - in front of a [parameter clause](06-basic-declarations-and-definitions.html#function-declarations-and-definitions), and - after an [annotation](13-user-defined-annotations.html#user-defined-annotations). -### Example: +### Example The newline tokens between the two lines are not treated as statement separators. -``` +```scala if (x > 0) x = x - 1 @@ -226,9 +226,9 @@ type IntList = List[Int] ``` -### Example: +### Example -``` +```scala new Iterator[Int] { private var x = 0 @@ -240,7 +240,7 @@ new Iterator[Int] With an additional newline character, the same code is interpreted as an object creation followed by a local block: -``` +```scala new Iterator[Int] { @@ -250,9 +250,9 @@ new Iterator[Int] } ``` -### Example: +### Example -``` +```scala x < 0 || x > 10 ``` @@ -260,15 +260,15 @@ new Iterator[Int] With an additional newline character, the same code is interpreted as two expressions: -``` +```scala x < 0 || x > 10 ``` -### Example: +### Example -``` +```scala def func(x: Int) (y: Int) = x + y ``` @@ -276,15 +276,15 @@ def func(x: Int) With an additional newline character, the same code is interpreted as an abstract function definition and a syntactically illegal statement: -``` +```scala def func(x: Int) (y: Int) = x + y ``` -### Example: +### Example -``` +```scala @serializable protected class Data { ... } ``` @@ -293,7 +293,7 @@ With an additional newline character, the same code is interpreted as an attribute and a separate statement (which is syntactically illegal). -``` +```scala @serializable protected class Data { ... } @@ -311,7 +311,7 @@ each case as in Java. particular float and double. --> -``` +```ebnf Literal ::= [‘-’] integerLiteral | [‘-’] floatingPointLiteral | booleanLiteral @@ -324,7 +324,7 @@ Literal ::= [‘-’] integerLiteral ### Integer Literals -``` +```ebnf integerLiteral ::= (decimalNumeral | hexNumeral | octalNumeral) [‘L’ | ‘l’] decimalNumeral ::= ‘0’ | nonZeroDigit {digit} @@ -356,16 +356,16 @@ is _pt_. The numeric ranges given by these types are: |`Char` | $0$ to $2^{16}-1$ | -### Example: +### Example -``` +```scala 0 21 0xFFFFFFFF -42L ``` ### Floating Point Literals -``` +```ebnf floatingPointLiteral ::= digit {digit} ‘.’ digit {digit} [exponentPart] [floatType] | ‘.’ digit {digit} [exponentPart] [floatType] | digit {digit} exponentPart [floatType] @@ -385,24 +385,24 @@ If a floating point literal in a program is followed by a token starting with a letter, there must be at least one intervening whitespace character between the two tokens. -### Example: +### Example -``` +```scala 0.0 1e30f 3.14159f 1.0e-100 .1 ``` -### Example: +### Example The phrase `1.toString` parses as three different tokens: the integer literal `1`, a `.`, and the identifier `toString`. -### Example: +### Example `1.` is not a valid floating point literal because the mandatory digit after the `.` is missing. ### Boolean Literals -``` +```ebnf booleanLiteral ::= ‘true’ | ‘false’ ``` @@ -412,7 +412,7 @@ members of type `Boolean`. ### Character Literals -``` +```ebnf characterLiteral ::= ‘'’ (printableChar | charEscapeSeq) ‘'’ ``` @@ -420,9 +420,9 @@ A character literal is a single character enclosed in quotes. The character is either a printable unicode character or is described by an [escape sequence](#escape-sequences). -### Example: +### Example -``` +```scala 'a' '\u0041' '\n' '\t' ``` @@ -435,7 +435,7 @@ the octal escape `'\12'` ([see here](#escape-sequences)). ### String Literals -``` +```ebnf stringLiteral ::= ‘"’ {stringElement} ‘"’ stringElement ::= printableCharNoDoubleQuote | charEscapeSeq ``` @@ -447,16 +447,16 @@ contains a double quote character, it must be escaped, i.e. `"\""`. The value of a string literal is an instance of class `String`. -### Example: +### Example -``` +```scala "Hello,\nWorld!" "This string contains a \" character." ``` #### Multi-Line String Literals -``` +```ebnf stringLiteral ::= ‘"""’ multiLineChars ‘"""’ multiLineChars ::= {[‘"’] [‘"’] charNoDoubleQuote} {‘"’} ``` @@ -469,9 +469,9 @@ must not necessarily be printable; newlines or other control characters are also permitted. Unicode escapes work as everywhere else, but none of the escape sequences [here](#escape-sequences) are interpreted. -### Example: +### Example -``` +```scala """the present string spans three lines.""" @@ -479,7 +479,7 @@ of the escape sequences [here](#escape-sequences) are interpreted. This would produce the string: -``` +```scala the present string spans three lines. @@ -489,7 +489,7 @@ The Scala library contains a utility method `stripMargin` which can be used to strip leading whitespace from multi-line strings. The expression -``` +```scala """the present string |spans three |lines.""".stripMargin @@ -497,7 +497,7 @@ The expression evaluates to -``` +```scala the present string spans three lines. @@ -536,7 +536,7 @@ string literal does not start a valid escape sequence. ### Symbol literals -``` +```ebnf symbolLiteral ::= ‘'’ plainid ``` @@ -544,7 +544,7 @@ A symbol literal `'x` is a shorthand for the expression `scala.Symbol("x")`. `Symbol` is a [case class](07-classes-and-objects.html#case-classes), which is defined as follows. -``` +```scala package scala final case class Symbol private (name: String) { override def toString: String = "'" + name @@ -580,7 +580,7 @@ angle bracket '<' in the following circumstance: The '<' must be preceded either by whitespace, an opening parenthesis or an opening brace and immediately followed by a character starting an XML name. -``` +```ebnf ( whitespace | ‘(’ | ‘{’ ) ‘<’ (XNameStart | ‘!’ | ‘?’) XNameStart ::= ‘_’ | BaseChar | Ideographic // as in W3C XML, but without ‘:’ @@ -600,12 +600,12 @@ The scanner switches from XML mode to Scala mode if either Note that no Scala tokens are constructed in XML mode, and that comments are interpreted as text. -### Example: +### Example The following value definition uses an XML literal with two embedded Scala expressions: -``` +```scala val b = The Scala Language Specification {scalaBook.version} diff --git a/04-identifiers-names-and-scopes.md b/04-identifiers-names-and-scopes.md index 96b4f283e996..0a3f9ca3cf84 100644 --- a/04-identifiers-names-and-scopes.md +++ b/04-identifiers-names-and-scopes.md @@ -39,7 +39,7 @@ scopes. Note that shadowing is only a partial order. In a situation like -``` +```scala val x = 1 { import p.x @@ -71,11 +71,11 @@ namespace as the identifier. It is an error if $T$ is not a [value type](05-type The type of $e.x$ is the member type of the referenced entity in $T$. -### Example: +### Example Assume the following two definitions of a objects named `X` in packages `P` and `Q`. -``` +```scala package P { object X { val x = 1; val y = 2 } } @@ -88,7 +88,7 @@ package Q { The following program illustrates different kinds of bindings and precedences between them. -``` +```scala package P { // `X' bound by package clause import Console._ // `println' bound by wildcard import object A { diff --git a/05-types.md b/05-types.md index c2996ddb4b66..f614d15f8f03 100644 --- a/05-types.md +++ b/05-types.md @@ -6,7 +6,7 @@ chapter: 3 # Types -``` +```ebnf Type ::= FunctionArgTypes ‘=>’ Type | InfixType [ExistentialClause] FunctionArgTypes ::= InfixType @@ -66,7 +66,7 @@ the corresponding anonymous type function directly. ## Paths -``` +```ebnf Path ::= StableId | [id ‘.’] this StableId ::= id @@ -103,7 +103,7 @@ forms. ### Singleton Types -``` +```ebnf SimpleType ::= Path ‘.’ type ``` @@ -117,7 +117,7 @@ declared to be a subtype of trait `scala.Singleton`. ### Type Projection -``` +```ebnf SimpleType ::= SimpleType ‘#’ id ``` @@ -132,7 +132,7 @@ If $x$ references an abstract type member, then $T$ must be a ### Type Designators -``` +```ebnf SimpleType ::= StableId ``` @@ -149,7 +149,7 @@ A qualified type designator has the form `p.t` where `p` is a [path](#paths) and _t_ is a type name. Such a type designator is equivalent to the type projection `p.type#t`. -### Example: +### Example Some type designators and their expansions are listed below. We assume a local type parameter $t$, a value `maintable` @@ -166,7 +166,7 @@ with a type member `Node` and the standard class `scala.Int`, ### Parameterized Types -``` +```ebnf SimpleType ::= SimpleType TypeArgs TypeArgs ::= ‘[’ Types ‘]’ ``` @@ -182,10 +182,10 @@ well-formed if each actual type parameter _conforms to its bounds_, i.e. $\sigma L_i <: T_i <: \sigma U_i$ where $\sigma$ is the substitution $[ a_1 := T_1 , \ldots , a_n := T_n ]$. -### Example: +### Example Given the partial type definitions: -``` +```scala class TreeMap[A <: Comparable[A], B] { … } class List[A] { … } class I extends Comparable[I] { … } @@ -197,7 +197,7 @@ class G[M[ Z <: I ], I] { … } the following parameterized types are well formed: -``` +```scala TreeMap[I, String] List[I] List[List[Boolean]] @@ -206,12 +206,12 @@ F[List, Int] G[S, String] ``` -### Example: +### Example Given the [above type definitions](example-parameterized-types), the following types are ill-formed: -``` +```scala TreeMap[I] // illegal: wrong number of parameters TreeMap[List[I], Int] // illegal: type parameter not within bound @@ -226,7 +226,7 @@ G[S, Int] // illegal: S constrains its parameter to ### Tuple Types -``` +```ebnf SimpleType ::= ‘(’ Types ‘)’ ``` @@ -240,7 +240,7 @@ class and product trait are defined at least as follows in the standard Scala library (they might also add other methods and implement other traits). -``` +```scala case class Tuple$n$[+T1, … , +$T_n$](_1: T1, … , _n: $T_n$) extends Product_n[T1, … , $T_n$] @@ -254,7 +254,7 @@ trait Product_n[+T1, … , +$T_n$] { ### Annotated Types -``` +```ebnf AnnotType ::= SimpleType {Annotation} ``` @@ -262,18 +262,18 @@ An annotated type $T$ `$a_1 , \ldots , a_n$` attaches [annotations](13-user-defined-annotations.html#user-defined-annotations) $a_1 , \ldots , a_n$ to the type $T$. -### Example: +### Example The following type adds the `@suspendable` annotation to the type `String`: -``` +```scala String @suspendable ``` ### Compound Types -``` +```ebnf CompoundType ::= AnnotType {‘with’ AnnotType} [Refinement] | Refinement Refinement ::= [nl] ‘{’ RefineStat {semi RefineStat} ‘}’ @@ -310,12 +310,12 @@ A compound type may also consist of just a refinement `{ $R$ }` with no preceding component types. Such a type is equivalent to `AnyRef{ R }`. -### Example: +### Example The following example shows how to declare and use a method which a parameter type that contains a refinement with structural declarations. -``` +```scala case class Bird (val name: String) extends Object { def fly(height: Int) = … … @@ -345,7 +345,7 @@ a value `callsign` and a `fly` method. ### Infix Types -``` +```ebnf InfixType ::= CompoundType {id [nl] CompoundType} ``` @@ -374,7 +374,7 @@ $t_0 \mathit{op_1} (t_1 \mathit{op_2} ( \ldots \mathit{op_n} t_n) \ldots)$. ### Function Types -``` +```ebnf Type ::= FunctionArgs ‘=>’ Type FunctionArgs ::= InfixType | ‘(’ [ ParamType {‘,’ ParamType } ] ‘)’ @@ -397,7 +397,7 @@ $(T_1 , \ldots , T_n) \Rightarrow U$ is a shorthand for the class type `Function$_n$[T1 , … , $T_n$, U]`. Such class types are defined in the Scala library for $n$ between 0 and 9 as follows. -``` +```scala package scala trait Function_n[-T1 , … , -T$_n$, +R] { def apply(x1: T1 , … , x$_n$: T$_n$): R @@ -410,7 +410,7 @@ result type and contravariant in their argument types. ### Existential Types -``` +```ebnf Type ::= InfixType ExistentialClauses ExistentialClauses ::= ‘forSome’ ‘{’ ExistentialDcl {semi ExistentialDcl} ‘}’ @@ -479,7 +479,7 @@ fresh type name and $T'$ results from $T$ by replacing every occurrence of #### Placeholder Syntax for Existential Types -``` +```ebnf WildcardType ::= ‘_’ TypeBounds ``` @@ -499,7 +499,7 @@ $T$ is a wildcard type `_$\;$>:$\,L\,$<:$\,U$`. Then $T$ is equivalent to the existential type -``` +```scala $p.c[\mathit{targs},t,\mathit{targs}']$ forSome { type $t$ >: $L$ <: $U$ } ``` @@ -510,18 +510,18 @@ or [tuple types](#tuple-types). Their expansion is then the expansion in the equivalent parameterized type. -### Example: +### Example Assume the class definitions -``` +```scala class Ref[T] abstract class Outer { type T } . ``` Here are some examples of existential types: -``` +```scala Ref[T] forSome { type T <: java.lang.Number } Ref[x.T] forSome { val x: Outer } Ref[x_type # T] forSome { type x_type <: Outer with Singleton } @@ -530,35 +530,35 @@ Ref[x_type # T] forSome { type x_type <: Outer with Singleton } The last two types in this list are equivalent. An alternative formulation of the first type above using wildcard syntax is: -``` +```scala Ref[_ <: java.lang.Number] ``` -### Example: +### Example The type `List[List[_]]` is equivalent to the existential type -``` +```scala List[List[t] forSome { type t }] . ``` -### Example: +### Example Assume a covariant type -``` +```scala class List[+T] ``` The type -``` +```scala List[T] forSome { type T <: java.lang.Number } ``` is equivalent (by simplification rule 4 above) to -``` +```scala List[java.lang.Number] forSome { type T <: java.lang.Number } ``` @@ -606,7 +606,7 @@ def c (x: Int) (y: String, z: String): String produce the typings -``` +```scala a: => Int b: (Int) Boolean c: (Int) (String, String) String @@ -628,14 +628,14 @@ take type arguments `$S_1 , \ldots , S_n$` which The declarations -``` +```scala def empty[A]: List[A] def union[A <: Comparable[A]] (x: Set[A], xs: Set[A]): Set[A] ``` produce the typings -``` +```scala empty : [A >: Nothing <: Any] List[A] union : [A >: Nothing <: Comparable[A]] (x: Set[A], xs: Set[A]) Set[A] . ``` @@ -671,7 +671,7 @@ same name, we model An overloaded type consisting of type alternatives $T_1 \commadots T_n (n \geq 2)$ is denoted internally $T_1 \overload \ldots \overload T_n$. -### Example: +### Example ``` def println: Unit def println(s: String): Unit = $\ldots$ @@ -689,7 +689,7 @@ println: => Unit $\overload$ [A] (A) (A => String) Unit ``` -### Example: +### Example ``` def f(x: T): T = $\ldots$ val f = 0 @@ -944,7 +944,7 @@ The least upper bound or greatest lower bound of a set of types does not always exist. For instance, consider the class definitions -``` +```scala class A[+T] {} class B extends A[B] class C extends A[C] @@ -980,7 +980,7 @@ to a type $T$, written $S <:_w T$, if $S <: T$ or both $S$ and $T$ are primitive number types and $S$ precedes $T$ in the following ordering. -``` +```scala Byte $<:_w$ Short Short $<:_w$ Int Char $<:_w$ Int diff --git a/06-basic-declarations-and-definitions.md b/06-basic-declarations-and-definitions.md index 4507dab63f67..e0fdf051c24e 100644 --- a/06-basic-declarations-and-definitions.md +++ b/06-basic-declarations-and-definitions.md @@ -7,7 +7,7 @@ chapter: 4 # Basic Declarations and Definitions -``` +```ebnf Dcl ::= ‘val’ ValDcl | ‘var’ VarDcl | ‘def’ FunDcl @@ -102,7 +102,7 @@ case object Blue extends Color . ## Value Declarations and Definitions -``` +```ebnf Dcl ::= ‘val’ ValDcl ValDcl ::= ids ‘:’ Type PatVarDef ::= ‘val’ PatDef @@ -128,7 +128,7 @@ its right hand side $e$ the first time the value is accessed. A _constant value definition_ is of the form -``` +```scala final val x = e ``` @@ -145,7 +145,7 @@ value definition `val $p$ = $e$` is expanded as follows: 1. If the pattern $p$ has bound variables $x_1 , \ldots , x_n$, where $n > 1$: -``` +```scala val $\$ x$ = $e$ match {case $p$ => ($x_1 , \ldots , x_n$)} val $x_1$ = $\$ x$._1 $\ldots$ @@ -156,13 +156,13 @@ Here, $\$ x$ is a fresh name. 2. If $p$ has a unique bound variable $x$: -``` +```scala val $x$ = $e$ match { case $p$ => $x$ } ``` 3. If $p$ has no bound variables: -``` +```scala $e$ match { case $p$ => ()} ``` @@ -170,7 +170,7 @@ $e$ match { case $p$ => ()} The following are examples of value definitions -``` +```scala val pi = 3.1415 val pi: Double = 3.1415 // equivalent to first definition val Some(x) = f() // a pattern definition @@ -179,7 +179,7 @@ val x :: xs = mylist // an infix pattern definition The last two definitions have the following expansions. -``` +```scala val x = f() match { case Some(x) => x } val x$\$$ = mylist match { case x :: xs => (x, xs) } @@ -200,7 +200,7 @@ sequence of value definitions `val $p_1: T$ = $e$; ...; val $p_n: T$ = $e$`. ## Variable Declarations and Definitions -``` +```ebnf Dcl ::= ‘var’ VarDcl PatVarDef ::= ‘var’ VarDef VarDcl ::= ids ‘:’ Type @@ -211,7 +211,7 @@ VarDef ::= PatDef A variable declaration `var $x$: $T$` is equivalent to the declarations of both a _getter function_ $x$ *and* a _setter function_ `$x$_=`: -``` +```scala def $x$: $T$ def $x$_= ($y$: $T$): Unit ``` @@ -268,7 +268,7 @@ seconds. Its implementation contains tests that allow only legal values to be assigned to these fields. The user code, on the other hand, accesses these fields just like normal variables. -``` +```scala class TimeOfDayVar { private var h: Int = 0 private var m: Int = 0 @@ -304,7 +304,7 @@ the sequence of variable definitions -``` +```ebnf Dcl ::= ‘type’ {nl} TypeDcl TypeDcl ::= id [TypeParamClause] [‘>:’ Type] [‘<:’ Type] Def ::= type {nl} TypeDef @@ -354,7 +354,7 @@ an abstract type is directly or indirectly its own upper or lower bound. The following are legal type declarations and definitions: -``` +```scala type IntList = List[Integer] type T <: Comparable[T] type Two[A] = Tuple2[A, A] @@ -363,7 +363,7 @@ type MyCollection[+X] <: Iterable[X] The following are illegal: -``` +```scala type Abs = Comparable[Abs] // recursive type alias type S <: T // S, T are bounded by themselves. @@ -384,7 +384,7 @@ objects of type $S$. The `Predef` object contains a definition which establishes `Pair` as an alias of the parameterized class `Tuple2`: -``` +```scala type Pair[+A, +B] = Tuple2[A, B] object Pair { def apply[A, B](x: A, y: B) = Tuple2(x, y) @@ -396,14 +396,14 @@ As a consequence, for any two types $S$ and $T$, the type `Pair[$S$, $T\,$]` is equivalent to the type `Tuple2[$S$, $T\,$]`. `Pair` can also be used as a constructor instead of `Tuple2`, as in: -``` +```scala val x: Pair[Int, String] = new Pair(1, "abc") ``` ## Type Parameters -``` +```ebnf TypeParamClause ::= ‘[’ VariantTypeParam {‘,’ VariantTypeParam} ‘]’ VariantTypeParam ::= {Annotation} [‘+’ | ‘-’] TypeParam TypeParam ::= (id | ‘_’) [TypeParamClause] [‘>:’ Type] [‘<:’ Type] [‘:’ Type] @@ -443,7 +443,7 @@ The above scoping restrictions are generalized to the case of nested type parame ###### Example Here are some well-formed type parameter clauses: -``` +```scala [S, T] [@specialized T, U] [Ex <: Throwable] @@ -457,7 +457,7 @@ Here are some well-formed type parameter clauses: The following type parameter clauses are illegal: -``` +```scala [A >: A] // illegal, `A' has itself as bound [A <: B, B <: C, C <: A] // illegal, `A' has itself as bound [A, B, C >: A <: B] // illegal lower bound `A' of `C' does @@ -518,7 +518,7 @@ appear anywhere without restricting its legal variance annotations. ###### Example The following variance annotation is legal. -``` +```scala abstract class P[+A, +B] { def fst: A; def snd: B } @@ -528,14 +528,14 @@ With this variance annotation, type instances of $P$ subtype covariantly with respect to their arguments. For instance, -``` +```scala P[IOException, String] <: P[Throwable, AnyRef] ``` If the members of $P$ are mutable variables, the same variance annotation becomes illegal. -``` +```scala abstract class Q[+A, +B](x: A, y: B) { var fst: A = x // **** error: illegal variance: var snd: B = y // `A', `B' occur in invariant position. @@ -545,7 +545,7 @@ abstract class Q[+A, +B](x: A, y: B) { If the mutable variables are object-private, the class definition becomes legal again: -``` +```scala abstract class R[+A, +B](x: A, y: B) { private[this] var fst: A = x // OK private[this] var snd: B = y // OK @@ -557,7 +557,7 @@ abstract class R[+A, +B](x: A, y: B) { The following variance annotation is illegal, since $a$ appears in contravariant position in the parameter of `append`: -``` +```scala abstract class Sequence[+A] { def append(x: Sequence[A]): Sequence[A] // **** error: illegal variance: @@ -568,15 +568,15 @@ abstract class Sequence[+A] { The problem can be avoided by generalizing the type of `append` by means of a lower bound: -``` +```scala abstract class Sequence[+A] { def append[B >: A](x: Sequence[B]): Sequence[B] } ``` -### Example: +### Example -``` +```scala abstract class OutputChannel[-A] { def write(x: A): Unit } @@ -591,7 +591,7 @@ on which one can write only strings. ## Function Declarations and Definitions -``` +```ebnf Dcl ::= ‘def’ FunDcl FunDcl ::= FunSig ‘:’ Type Def ::= ‘def’ FunDef @@ -655,7 +655,7 @@ be pairwise distinct. ###### Example In the method -``` +```scala def compare[T](a: T = 0)(b: T = a) = (a == b) ``` @@ -664,7 +664,7 @@ type. When applying `compare()`, the default value `0` is inserted and `T` is instantiated to `Int`. The methods computing the default arguments have the form: -``` +```scala def compare$\$$default$\$$1[T]: Int = 0 def compare$\$$default$\$$2[T](a: T): T = a ``` @@ -673,7 +673,7 @@ def compare$\$$default$\$$2[T](a: T): T = a ### By-Name Parameters -``` +```ebnf ParamType ::= ‘=>’ Type ``` @@ -693,7 +693,7 @@ by-name modifier is also disallowed for ###### Example The declaration -``` +```scala def whileLoop (cond: => Boolean) (stat: => Unit): Unit ``` @@ -703,7 +703,7 @@ call-by-name. ### Repeated Parameters -``` +```ebnf ParamType ::= Type ‘*’ ``` @@ -732,7 +732,7 @@ with a repeated parameter. The following method definition computes the sum of the squares of a variable number of integer arguments. -``` +```scala def sum(args: Int*) = { var result = 0 for (arg <- args) result += arg * arg @@ -743,7 +743,7 @@ def sum(args: Int*) = { The following applications of this method yield `0`, `1`, `6`, in that order. -``` +```scala sum() sum(1) sum(1, 2, 3) @@ -751,27 +751,27 @@ sum(1, 2, 3) Furthermore, assume the definition: -``` +```scala val xs = List(1, 2, 3) ``` The following application of method `sum` is ill-formed: -``` +```scala sum(xs) // ***** error: expected: Int, found: List[Int] ``` By contrast, the following application is well formed and yields again the result `6`: -``` +```scala sum(xs: _*) ``` ### Procedures -``` +```ebnf FunDcl ::= FunSig FunDef ::= FunSig [nl] ‘{’ Block ‘}’ ``` @@ -791,7 +791,7 @@ E.g., `def $f$($\mathit{ps}$) {$\mathit{stats}$}` is equivalent to ###### Example Here is a declaration and a definition of a procedure named `write`: -``` +```scala trait Writer { def write(str: String) } @@ -802,7 +802,7 @@ object Terminal extends Writer { The code above is implicitly completed to the following code: -``` +```scala trait Writer { def write(str: String): Unit } @@ -826,7 +826,7 @@ as $R$ conforms to $R'$. ###### Example Assume the following definitions: -``` +```scala trait I { def factorial(x: Int): Int } @@ -859,7 +859,7 @@ $T_j$ have the same erasure (\sref{sec:erasure}). ## Import Clauses -``` +```ebnf Import ::= ‘import’ ImportExpr {‘,’ ImportExpr} ImportExpr ::= StableId ‘.’ (id | ‘_’ | ImportSelectors) ImportSelectors ::= ‘{’ {ImportSelector ‘,’} @@ -874,7 +874,7 @@ which are made available without qualification. A member $m$ of $p$ is _importable_ if it is not [object-private](07-classes-and-objects.html#modifiers). The most general form of an import expression is a list of _import selectors_ -``` +```scala { $x_1$ => $y_1 , \ldots , x_n$ => $y_n$, _ } ``` @@ -925,7 +925,7 @@ sequence of import clauses ###### Example Consider the object definition: -``` +```scala object M { def z = 0, one = 1 def add(x: Int, y: Int): Int = x + y @@ -934,12 +934,12 @@ object M { Then the block -``` +```scala { import M.{one, z => zero, _}; add(zero, one) } ``` is equivalent to the block -``` +```scala { M.add(M.z, M.one) } ``` diff --git a/07-classes-and-objects.md b/07-classes-and-objects.md index d16be195869e..4ad637f51726 100644 --- a/07-classes-and-objects.md +++ b/07-classes-and-objects.md @@ -6,7 +6,7 @@ chapter: 5 # Classes and Objects -``` +```ebnf TmplDef ::= [`case'] `class' ClassDef | [`case'] `object' ObjectDef | `trait' TraitDef @@ -18,7 +18,7 @@ are both defined in terms of _templates_. ## Templates -``` +```ebnf ClassTemplate ::= [EarlyDefs] ClassParents [TemplateBody] TraitTemplate ::= [EarlyDefs] TraitParents [TemplateBody] ClassParents ::= Constr {`with' AnnotType} @@ -96,7 +96,7 @@ without introducing an alias name for it. ###### Example Consider the following class definitions: -``` +```scala class Base extends Object {} trait Mixin extends Base {} object O extends Mixin {} @@ -104,7 +104,7 @@ object O extends Mixin {} In this case, the definition of `O` is expanded to: -``` +```scala object O extends Base with Mixin {} ``` @@ -141,14 +141,14 @@ it. But templates inheriting the `scala.DelayedInit` trait can override the hook by re-implementing the `delayedInit` method, which is defined as follows: -``` +```scala def delayedInit(body: => Unit) ``` ### Constructor Invocations -``` +```ebnf Constr ::= AnnotType {`(' [Exprs] `)'} ``` @@ -199,7 +199,7 @@ $\mathcal{L}(C) = C, \mathcal{L}(C_n) \; \vec{+} \; \ldots \; \vec{+} \; \mathca Here $\vec{+}$ denotes concatenation where elements of the right operand replace identical elements of the left operand: -``` +```scala \[ \begin{array}{lcll} \{a, A\} \;\vec{+}\; B &=& a, (A \;\vec{+}\; B) &{\bf if} \; a \not\in B \\ @@ -212,7 +212,7 @@ replace identical elements of the left operand: ###### Example Consider the following class definitions. -``` +```scala abstract class AbsIterator extends AnyRef { ... } trait RichIterator extends AbsIterator { ... } class StringIterator extends AbsIterator { ... } @@ -221,7 +221,7 @@ class Iter extends StringIterator with RichIterator { ... } Then the linearization of class `Iter` is -``` +```scala { Iter, RichIterator, StringIterator, AbsIterator, AnyRef, Any } ``` @@ -233,7 +233,7 @@ a linearization of a class always contains the linearization of its direct super For instance, the linearization of `StringIterator` is -``` +```scala { StringIterator, AbsIterator, AnyRef, Any } ``` @@ -241,7 +241,7 @@ which is a suffix of the linearization of its subclass `Iter`. The same is not true for the linearization of mixins. For instance, the linearization of `RichIterator` is -``` +```scala { RichIterator, AbsIterator, AnyRef, Any } ``` @@ -312,7 +312,7 @@ defined or inherited) with the same name which both define default arguments. ###### Example Consider the trait definitions: -``` +```scala trait A { def f: Int } trait B extends A { def f: Int = 1 ; def g: Int = 2 ; def h: Int = 3 } trait C extends A { override def f: Int = 4 ; def g: Int } @@ -357,7 +357,7 @@ $M'$: A stable member can only be overridden by a stable member. For example, this is not allowed: -``` +```scala class X { val stable = 1} class Y extends X { override var stable = 1 } // error ``` @@ -378,11 +378,11 @@ it is possible to add new defaults (if the corresponding parameter in the superclass does not have a default) or to override the defaults of the superclass (otherwise). -### Example: +### Example Consider the definitions: -``` +```scala trait Root { type T <: Root } trait A extends Root { type T <: A } trait B extends Root { type T <: B } @@ -396,7 +396,7 @@ which fails to subsume the binding `type T <: A` of `T` in type `A`. The problem can be solved by adding an overriding definition of type `T` in class `C`: -``` +```scala class C extends A with B { type T <: C } ``` @@ -418,7 +418,7 @@ necessary to make subtyping decidable [@kennedy-pierce:decidable]). ### Early Definitions -``` +```ebnf EarlyDefs ::= `{' [EarlyDef {semi EarlyDef}] `}' `with' EarlyDef ::= {Annotation} {Modifier} PatVarDef ``` @@ -427,7 +427,7 @@ A template may start with an _early field definition_ clause, which serves to define certain field values before the supertype constructor is called. In a template -``` +```scala { val $p_1$: $T_1$ = $e_1$ ... val $p_n$: $T_n$ = $e_n$ @@ -462,7 +462,7 @@ before the superclass constructor of the template is called. Early definitions are particularly useful for traits, which do not have normal constructor parameters. Example: -``` +```scala trait Greeting { val name: String val msg = "How are you, "+name @@ -486,7 +486,7 @@ body, it would be initialized after the constructor of ## Modifiers -``` +```ebnf Modifier ::= LocalModifier | AccessModifier | `override' @@ -634,7 +634,7 @@ and a later access will retry to evaluate its right hand side. ###### Example The following code illustrates the use of qualified private: -``` +```scala package outerpkg.innerpkg class Outer { class Inner { @@ -659,7 +659,7 @@ A useful idiom to prevent clients of a class from constructing new instances of that class is to declare the class `abstract` and `sealed`: -``` +```scala object m { abstract sealed class C (x: Int) { def nextC = new C(x + 1) {} @@ -673,7 +673,7 @@ For instance, in the code above clients can create instances of class object; it is not possible for clients to create objects of class `m.C` directly. Indeed the following two lines are both in error: -``` +```scala new m.C(0) // **** error: C is abstract, so it cannot be instantiated. new m.C(0) {} // **** error: illegal inheritance from sealed class. ``` @@ -684,7 +684,7 @@ constructor `private` ([example](#example-private-constructor)). ## Class Definitions -``` +```ebnf TmplDef ::= `class' ClassDef ClassDef ::= id [TypeParamClause] {Annotation} [AccessModifier] ClassParamClauses ClassTemplateOpt @@ -699,7 +699,7 @@ ClassTemplateOpt ::= `extends' ClassTemplate | [[`extends'] TemplateBody] The most general form of class definition is -``` +```scala class $c$[$\mathit{tps}\,$] $as$ $m$($\mathit{ps}_1$)$\ldots$($\mathit{ps}_n$) extends $t$ $\gap(n \geq 0)$. ``` @@ -760,10 +760,10 @@ which when applied to parameters conforming to types $\mathit{ps}$ initializes instances of type `$c$[$\mathit{tps}\,$]` by evaluating the template $t$. -### Example: +### Example The following example illustrates `val` and `var` parameters of a class `C`: -``` +```scala class C(x: Int, val y: String, var z: List[String]) val c = new C(1, "abc", List()) c.z = c.y :: c.z @@ -771,7 +771,7 @@ c.z = c.y :: c.z The following class can be created only from its companion module. -``` +```scala object Sensitive { def makeSensitive(credentials: Certificate): Sensitive = if (credentials == Admin) new Sensitive() @@ -785,7 +785,7 @@ class Sensitive private () { ### Constructor Definitions -``` +```ebnf FunDef ::= `this' ParamClause ParamClauses (`=' ConstrExpr | [nl] ConstrBlock) ConstrExpr ::= SelfInvocation @@ -838,7 +838,7 @@ primary constructor of the class). ###### Example Consider the class definition -``` +```scala class LinkedList[A]() { var head = _ var tail = null @@ -855,7 +855,7 @@ third one constructs a list with a given head and tail. ## Case Classes -``` +```ebnf TmplDef ::= `case' `class' ClassDef ``` @@ -875,7 +875,7 @@ parameters $\mathit{tps}$ and value parameters $\mathit{ps}$ implicitly generates an [extractor object](10-pattern-matching.html#extractor-patterns) which is defined as follows: -``` +```scala object $c$ { def apply[$\mathit{tps}\,$]($\mathit{ps}_1\,$)$\ldots$($\mathit{ps}_n$): $c$[$\mathit{tps}\,$] = new $c$[$\mathit{Ts}\,$]($\mathit{xs}_1\,$)$\ldots$($\mathit{xs}_n$) def unapply[$\mathit{tps}\,$]($x$: $c$[$\mathit{tps}\,$]) = @@ -900,7 +900,7 @@ If the case class definition contains an empty value parameter list, the `unapply` method returns a `Boolean` instead of an `Option` type and is defined as follows: -``` +```scala def unapply[$\mathit{tps}\,$]($x$: $c$[$\mathit{tps}\,$]) = x ne null ``` @@ -915,7 +915,7 @@ A method named `copy` is implicitly added to every case class unless the class already has a member (directly defined or inherited) with that name, or the class has a repeated parameter. The method is defined as follows: -``` +```scala def copy[$\mathit{tps}\,$]($\mathit{ps}'_1\,$)$\ldots$($\mathit{ps}'_n$): $c$[$\mathit{tps}\,$] = new $c$[$\mathit{Ts}\,$]($\mathit{xs}_1\,$)$\ldots$($\mathit{xs}_n$) ``` @@ -946,7 +946,7 @@ class different from `AnyRef`. In particular: ###### Example Here is the definition of abstract syntax for lambda calculus: -``` +```scala class Expr case class Var (x: String) extends Expr case class Apply (f: Expr, e: Expr) extends Expr @@ -957,7 +957,7 @@ This defines a class `Expr` with case classes `Var`, `Apply` and `Lambda`. A call-by-value evaluator for lambda expressions could then be written as follows. -``` +```scala type Env = String => Value case class Value(e: Expr, env: Env) @@ -976,7 +976,7 @@ def eval(e: Expr, env: Env): Value = e match { It is possible to define further case classes that extend type `Expr` in other parts of the program, for instance -``` +```scala case class Number(x: Int) extends Expr ``` @@ -988,7 +988,7 @@ directly extend `Expr` must be in the same source file as ### Traits -``` +```ebnf TmplDef ::= `trait' TraitDef TraitDef ::= id [TypeParamClause] TraitTemplateOpt TraitTemplateOpt ::= `extends' TraitTemplate | [[`extends'] TemplateBody] @@ -1010,14 +1010,14 @@ it is not statically known at the time the trait is defined. If $D$ is not a trait, then its actual supertype is simply its least proper supertype (which is statically known). -### Example: +### Example The following trait defines the property of being comparable to objects of some type. It contains an abstract method `<` and default implementations of the other comparison operators `<=`, `>`, and `>=`. -``` +```scala trait Comparable[T <: Comparable[T]] { self: T => def < (that: T): Boolean def <=(that: T): Boolean = this < that || this == that @@ -1035,7 +1035,7 @@ given key. Finally, there is a method `apply` which is like `get`, except that it returns a given default value if the table is undefined for the given key. This class is implemented as follows. -``` +```scala abstract class Table[A, B](defaultValue: B) { def get(key: A): Option[B] def set(key: A, value: B) @@ -1048,7 +1048,7 @@ abstract class Table[A, B](defaultValue: B) { Here is a concrete implementation of the `Table` class. -``` +```scala class ListTable[A, B](defaultValue: B) extends Table[A, B](defaultValue) { private var elems: List[(A, B)] def get(key: A) = elems.find(._1.==(key)).map(._2) @@ -1059,7 +1059,7 @@ class ListTable[A, B](defaultValue: B) extends Table[A, B](defaultValue) { Here is a trait that prevents concurrent access to the `get` and `set` operations of its parent class: -``` +```scala trait SynchronizedTable[A, B] extends Table[A, B] { abstract override def get(key: A): B = synchronized { super.get(key) } @@ -1080,7 +1080,7 @@ Finally, the following mixin composition creates a synchronized list table with strings as keys and integers as values and with a default value `0`: -``` +```scala object MyTable extends ListTable[String, Int](0) with SynchronizedTable ``` @@ -1093,7 +1093,7 @@ in `MyTable`. ## Object Definitions -``` +```ebnf ObjectDef ::= id ClassTemplate ``` @@ -1103,7 +1103,7 @@ most general form is $m$ is the name of the object to be defined, and $t$ is a [template](#templates) of the form -``` +```scala $sc$ with $mt_1$ with $\ldots$ with $mt_n$ { $\mathit{stats}$ } ``` @@ -1118,7 +1118,7 @@ The object definition defines a single object (or: _module_) conforming to the template $t$. It is roughly equivalent to the following definition of a lazy value: -``` +```scala lazy val $m$ = new $sc$ with $mt_1$ with $\ldots$ with $mt_n$ { this: $m.type$ => $\mathit{stats}$ } ``` @@ -1142,7 +1142,7 @@ Classes in Scala do not have static members; however, an equivalent effect can be achieved by an accompanying object definition E.g. -``` +```scala abstract class Point { val x: Double val y: Double diff --git a/08-expressions.md b/08-expressions.md index 1c72e4734eea..db1bd182cd5a 100644 --- a/08-expressions.md +++ b/08-expressions.md @@ -6,7 +6,7 @@ chapter: 6 # Expressions -``` +```ebnf Expr ::= (Bindings | id | `_') `=>' Expr | Expr1 Expr1 ::= `if' `(' Expr `)' {nl} Expr [[semi] `else' Expr] @@ -66,14 +66,14 @@ type $T$ and let $t_1[\mathit{tps}_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}_ all the type variables created by skolemization of some part of $e$ which are free in $T$. Then the _packed type_ of $e$ is -``` +```scala $T$ forSome { type $t_1[\mathit{tps}_1] >: L_1 <: U_1$; $\ldots$; type $t_n[\mathit{tps}_n] >: L_n <: U_n$ }. ``` ## Literals -``` +```ebnf SimpleExpr ::= Literal ``` @@ -102,7 +102,7 @@ A reference to any other member of the "null" object causes a ## Designators -``` +```ebnf SimpleExpr ::= Path | SimpleExpr `.' id ``` @@ -160,7 +160,7 @@ is thrown. ## This and Super -``` +```ebnf SimpleExpr ::= [id `.'] `this' | [id '.'] `super' [ClassQualifier] `.' id ``` @@ -210,10 +210,10 @@ to the type or method of $x$ in the parent trait of $C$ whose simple name is $T$. That member must be uniquely defined. If it is a method, it must be concrete. -### Example: +### Example Consider the following class definitions -``` +```scala class Root { def x = "Root" } class A extends Root { override def x = "A" ; def superA = super.x } trait B extends Root { override def x = "B" ; def superB = super.x } @@ -229,7 +229,7 @@ The linearization of class `C` is `{C, B, Root}` and the linearization of class `D` is `{D, B, A, Root}`. Then we have: -``` +```scala (new A).superA == "Root", (new C).superB = "Root", (new C).superC = "B", (new D).superA == "Root", (new D).superB = "A", (new D).superD = "B", @@ -241,7 +241,7 @@ depending on whether `B` is mixed in with class `Root` or `A`. ## Function Applications -``` +```ebnf SimpleExpr ::= SimpleExpr1 ArgumentExprs ArgumentExprs ::= `(' [Exprs] `)' | `(' [Exprs `,'] PostfixExpr `:' `_' `*' ')' @@ -326,20 +326,20 @@ of the caller. Assume the following function which computes the sum of a variable number of arguments: -``` +```scala def sum(xs: Int*) = (0 /: xs) ((x, y) => x + y) ``` Then -``` +```scala sum(1, 2, 3, 4) sum(List(1, 2, 3, 4): _*) ``` both yield `10` as result. On the other hand, -``` +```scala sum(List(1, 2, 3, 4)) ``` @@ -369,7 +369,7 @@ If the function $f$ has the form `$p.m$[$\mathit{targs}$]` it is transformed into the block -``` +```scala { val q = $p$ q.$m$[$\mathit{targs}$] } @@ -379,7 +379,7 @@ If the function $f$ is itself an application expression the transformation is applied recursively on $f$. The result of transforming $f$ is a block of the form -``` +```scala { val q = $p$ val $x_1$ = expr$_1$ $\ldots$ @@ -404,7 +404,7 @@ that the position of each name matches the position of its corresponding parameter in the method type `($p_1:T_1 , \ldots , p_n:T_n$)$U$`. The final result of the transformation is a block of the form -``` +```scala { val q = $p$ val $x_1$ = expr$_1$ $\ldots$ @@ -422,7 +422,7 @@ The final result of the transformation is a block of the form ## Method Values -``` +```ebnf SimpleExpr ::= SimpleExpr1 `_' ``` @@ -455,7 +455,7 @@ because otherwise the underscore would be considered part of the name. ## Type Applications -``` +```ebnf SimpleExpr ::= SimpleExpr TypeArgs ``` @@ -482,7 +482,7 @@ and the expected result type. ## Tuples -``` +```ebnf SimpleExpr ::= `(' [Exprs] `)' ``` @@ -495,7 +495,7 @@ The empty tuple ## Instance Creation Expressions -``` +```ebnf SimpleExpr ::= `new' (ClassTemplate | TemplateBody) ``` @@ -510,7 +510,7 @@ $T$. The concrete self type is normally $T$, except if the expression `new $c$` appears as the right hand side of a value definition -``` +```scala val $x$: $S$ = new $c$ ``` @@ -526,7 +526,7 @@ A general instance creation expression is of the form `new $t$` for some [class template](07-classes-and-objects.html#templates) $t$. Such an expression is equivalent to the block -``` +```scala { class $a$ extends $t$; new $a$ } ``` @@ -541,19 +541,19 @@ types: If `{$D$}` is a class body, then ###### Example Consider the following structural instance creation expression: -``` +```scala new { def getName() = "aaron" } ``` This is a shorthand for the general instance creation expression -``` +```scala new AnyRef{ def getName() = "aaron" } ``` The latter is in turn a shorthand for the block -``` +```scala { class anon\$X extends AnyRef{ def getName() = "aaron" }; new anon\$X } ``` @@ -562,7 +562,7 @@ where `anon\$X` is some freshly created name. ## Blocks -``` +```ebnf BlockExpr ::= ‘{’ CaseClauses ‘}’ | ‘{’ Block ‘}’ Block ::= BlockStat {semi BlockStat} [ResultExpr] @@ -609,14 +609,14 @@ $e$, which defines the result of the block. ###### Example Assuming a class `Ref[T](x: T)`, the block -``` +```scala { class C extends B {$\ldots$} ; new Ref(new C) } ``` has the type `Ref[_1] forSome { type _1 <: B }`. The block -``` +```scala { class C extends B {$\ldots$} ; new C } ``` @@ -627,7 +627,7 @@ the existentially quantified type ## Prefix, Infix, and Postfix Operations -``` +```ebnf PostfixExpr ::= InfixExpr [id [nl]] InfixExpr ::= PrefixExpr | InfixExpr id [nl] InfixExpr @@ -668,7 +668,7 @@ The _precedence_ of an infix operator is determined by the operator's first character. Characters are listed below in increasing order of precedence, with characters on the same line having the same precedence. -``` +```scala (all letters) | ^ @@ -742,7 +742,7 @@ operation `$l$ += $r$`, where $l$, $r$ are expressions. This operation can be re-interpreted as an operation which corresponds to the assignment -``` +```scala $l$ = $l$ + $r$ ``` @@ -762,7 +762,7 @@ The re-interpretation occurs if the following two conditions are fulfilled. ## Typed Expressions -``` +```ebnf Expr1 ::= PostfixExpr `:' CompoundType ``` @@ -773,7 +773,7 @@ the expression is the value of $e$ converted to type $T$. ###### Example Here are examples of well-typed and ill-typed expressions. -``` +```scala 1: Int // legal, of type Int 1: Long // legal, of type Long // 1: string // ***** illegal @@ -782,7 +782,7 @@ Here are examples of well-typed and ill-typed expressions. ## Annotated Expressions -``` +```ebnf Expr1 ::= PostfixExpr `:' Annotation {Annotation} ``` @@ -793,7 +793,7 @@ expression $e$. ## Assignments -``` +```ebnf Expr1 ::= [SimpleExpr `.'] id `=' Expr | SimpleExpr1 ArgumentExprs `=' Expr ``` @@ -825,11 +825,11 @@ Here are some assignment expressions and their equivalent expansions. `x.f(i, j) = e` x.f.update(i, j, e) -------------------------- --------------------- -### Example: +### Example Here is the usual imperative code for matrix multiplication. -``` +```scala def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = { val zss: Array[Array[Double]] = new Array(xss.length, yss(0).length) var i = 0 @@ -854,7 +854,7 @@ def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = { Desugaring the array accesses and assignments yields the following expanded version: -``` +```scala def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = { val zss: Array[Array[Double]] = new Array(xss.length, yss.apply(0).length) var i = 0 @@ -879,7 +879,7 @@ def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = { ## Conditional Expressions -``` +```ebnf Expr1 ::= `if' `(' Expr `)' {nl} Expr [[semi] `else' Expr] ``` @@ -905,7 +905,7 @@ evaluated as if it was `if ($e_1$) $e_2$ else ()`. ## While Loop Expressions -``` +```ebnf Expr1 ::= `while' `(' Expr ')' {nl} Expr ``` @@ -913,7 +913,7 @@ The while loop expression `while ($e_1$) $e_2$` is typed and evaluated as if it was an application of `whileLoop ($e_1$) ($e_2$)` where the hypothetical function `whileLoop` is defined as follows. -``` +```scala def whileLoop(cond: => Boolean)(body: => Unit): Unit = if (cond) { body ; whileLoop(cond)(body) } else {} ``` @@ -921,7 +921,7 @@ def whileLoop(cond: => Boolean)(body: => Unit): Unit = ## Do Loop Expressions -``` +```ebnf Expr1 ::= `do' Expr [semi] `while' `(' Expr ')' ``` @@ -932,7 +932,7 @@ A semicolon preceding the `while` symbol of a do loop expression is ignored. ## For Comprehensions and For Loops -``` +```ebnf Expr1 ::= `for' (`(' Enumerators `)' | `{' Enumerators `}') {nl} [`yield'] Expr Enumerators ::= Generator {semi Generator} @@ -961,7 +961,7 @@ The translation scheme is as follows. In a first step, every generator `$p$ <- $e$`, where $p$ is not [irrefutable](10-pattern-matching.html#patterns) for the type of $e$ is replaced by -``` +```scala $p$ <- $e$.withFilter { case $p$ => true; case _ => false } ``` @@ -1022,7 +1022,7 @@ comprehensions have been eliminated. The following code produces all pairs of numbers between $1$ and $n-1$ whose sums are prime. -``` +```scala for { i <- 1 until n j <- 1 until i if isPrime(i+j) @@ -1031,7 +1031,7 @@ for { i <- 1 until n The for comprehension is translated to: -``` +```scala (1 until n) .flatMap { case i => (1 until i) @@ -1046,7 +1046,7 @@ For instance, here is a function to compute the transpose of a given matrix: -``` +```scala def transpose[A](xss: Array[Array[A]]) = { for (i <- Array.range(0, xss(0).length)) yield for (xs <- xss) yield xs(i) @@ -1055,7 +1055,7 @@ def transpose[A](xss: Array[Array[A]]) = { Here is a function to compute the scalar product of two vectors: -``` +```scala def scalprod(xs: Array[Double], ys: Array[Double]) = { var acc = 0.0 for ((x, y) <- xs zip ys) acc = acc + x * y @@ -1066,7 +1066,7 @@ def scalprod(xs: Array[Double], ys: Array[Double]) = { Finally, here is a function to compute the product of two matrices. Compare with the [imperative version](#example-imperative-matrix-multiplication). -``` +```scala def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = { val ysst = transpose(yss) for (xs <- xss) yield @@ -1082,7 +1082,7 @@ The code above makes use of the fact that `map`, `flatMap`, ## Return Expressions -``` +```ebnf Expr1 ::= `return' [Expr] ``` @@ -1120,7 +1120,7 @@ and will propagate up the call stack. ## Throw Expressions -``` +```ebnf Expr1 ::= `throw' Expr ``` @@ -1138,7 +1138,7 @@ is `scala.Nothing`. ## Try Expressions -``` +```ebnf Expr1 ::= `try' `{' Block `}' [`catch' `{' CaseClauses `}'] [`finally' Expr] ``` @@ -1147,7 +1147,7 @@ A try expression is of the form `try { $b$ } catch $h$` where the handler $h$ is a [pattern matching anonymous function](#pattern-matching-anonymous-functions) -``` +```scala { case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ } ``` @@ -1193,7 +1193,7 @@ for `try { try { $b$ } catch $e_1$ } finally $e_2$`. ## Anonymous Functions -``` +```ebnf Expr ::= (Bindings | [`implicit'] id | `_') `=>' Expr ResultExpr ::= (Bindings | ([`implicit'] id | `_') `:' CompoundType) `=>' Block Bindings ::= `(' Binding {`,' Binding} `)' @@ -1221,7 +1221,7 @@ type which does not refer to any of the formal parameters $x_i$. The anonymous function is evaluated as the instance creation expression -``` +```scala new scala.Function$n$[$T_1 , \ldots , T_n$, $T$] { def apply($x_1$: $T_1 , \ldots , x_n$: $T_n$): $T$ = $e$ } @@ -1247,7 +1247,7 @@ anonymous functions always have to be given explicitly. ###### Example Examples of anonymous functions: -``` +```scala x => x // The identity function f => g => x => f(g(x)) // Curried function composition @@ -1266,7 +1266,7 @@ _ => 5 // The function that ignores its argument ### Placeholder Syntax for Anonymous Functions -``` +```ebnf SimpleExpr1 ::= `_' ``` @@ -1323,7 +1323,7 @@ include at least the expressions of the following forms: ## Statements -``` +```ebnf BlockStat ::= Import | {Annotation} [‘implicit’ | ‘lazy’] Def | {Annotation} {LocalModifier} TmplDef @@ -1380,7 +1380,7 @@ is applied to pick a unique member. ###### Type Instantiation An expression $e$ of polymorphic type -``` +```scala [$a_1$ >: $L_1$ <: $U_1 , \ldots , a_n$ >: $L_n$ <: $U_n$]$T$ ``` @@ -1557,7 +1557,7 @@ alternatives in $\mathscr{B}$. ###### Example Consider the following definitions: -``` +```scala class A extends B {} def f(x: B, y: B) = $\ldots$ def f(x: A, y: B) = $\ldots$ @@ -1569,7 +1569,7 @@ Then the application `f(b, b)` refers to the first definition of $f$ whereas the application `f(a, a)` refers to the second. Assume now we add a third overloaded definition -``` +```scala def f(x: B, y: A) = $\ldots$ ``` @@ -1670,14 +1670,14 @@ any one of them. ###### Example Consider the two methods: -``` +```scala def cons[A](x: A, xs: List[A]): List[A] = x :: xs def nil[B]: List[B] = Nil ``` and the definition -``` +```scala val xs = cons(1, nil) ``` @@ -1693,7 +1693,7 @@ has type `Int` whereas the second argument `nil` is itself polymorphic. One tries to type-check `nil` with an expected type `List[a]`. This leads to the constraint system -``` +```scala List[b?] <: List[a] ``` @@ -1702,14 +1702,14 @@ that it is a variable in the constraint system. Because class `List` is covariant, the optimal solution of this constraint is -``` +```scala b = scala.Nothing ``` In a second step, one solves the following constraint system for the type parameter `a` of `cons`: -``` +```scala Int <: a? List[scala.Nothing] <: List[a?] List[a?] <: $\mathit{undefined}$ @@ -1717,7 +1717,7 @@ List[a?] <: $\mathit{undefined}$ The optimal solution of this constraint system is -``` +```scala a = Int ``` @@ -1728,7 +1728,7 @@ so `Int` is the type inferred for `a`. Consider now the definition -``` +```scala val ys = cons("abc", xs) ``` @@ -1746,7 +1746,7 @@ the second strategy is tried; `xs` is now typed with expected type In a second step, one solves the following constraint system for the type parameter `a` of `cons`: -``` +```scala String <: a? List[Int] <: List[a?] List[a?] <: $\mathit{undefined}$ @@ -1754,7 +1754,7 @@ List[a?] <: $\mathit{undefined}$ The optimal solution of this constraint system is -``` +```scala a = scala.Any ``` @@ -1774,7 +1774,7 @@ corresponding fresh name $x_i$. Second, one creates a fresh name $y_i$ for every argument type $T_i$ of the method ($i = 1 , \ldots , n$). The result of eta-conversion is then: -``` +```scala { val $x_1$ = $e_1$; $\ldots$ val $x_m$ = $e_m$; @@ -1787,7 +1787,7 @@ n$). The result of eta-conversion is then: The standard Scala library defines a trait `scala.Dynamic` which defines a member \@invokeDynamic@ as follows: -``` +```scala package scala trait Dynamic { def applyDynamic (name: String, args: Any*): Any @@ -1798,14 +1798,14 @@ trait Dynamic { Assume a selection of the form $e.x$ where the type of $e$ conforms to `scala.Dynamic`. Further assuming the selection is not followed by any function arguments, such an expression can be rewitten under the conditions given [here](#implicit-conversions) to: -``` +```scala $e$.applyDynamic("$x$") ``` If the selection is followed by some arguments, e.g. $e.x(\mathit{args})$, then that expression is rewritten to -``` +```scala $e$.applyDynamic("$x$", $\mathit{args}$) ``` diff --git a/09-implicit-parameters-and-views.md b/09-implicit-parameters-and-views.md index 8cd54897c978..3e821ec9fa48 100644 --- a/09-implicit-parameters-and-views.md +++ b/09-implicit-parameters-and-views.md @@ -8,7 +8,7 @@ chapter: 7 ## The Implicit Modifier -``` +```ebnf LocalModifier ::= ‘implicit’ ParamClauses ::= {ParamClause} [nl] ‘(’ ‘implicit’ Params ‘)’ ``` @@ -19,12 +19,12 @@ and can be used as implicit conversions called [views](#views). The `implicit` modifier is illegal for all type members, as well as for [top-level objects](11-top-level-definitions.html#packagings). -### Example: +### Example The following code defines an abstract class of monoids and two concrete implementations, `StringMonoid` and `IntMonoid`. The two implementations are marked implicit. -``` +```scala abstract class Monoid[A] extends SemiGroup[A] { def unit: A def add(x: A, y: A): A @@ -101,7 +101,7 @@ Assuming the classes from the [`Monoid` example](#example-monoid), here is a method which computes the sum of a list of elements using the monoid's `add` and `unit` operations. -``` +```scala def sum[A](xs: List[A])(implicit m: Monoid[A]): A = if (xs.isEmpty) m.unit else m.add(xs.head, sum(xs.tail)) @@ -126,7 +126,7 @@ is the following method from module `scala.List`, which injects lists into the `scala.Ordered` class, provided the element type of the list is also convertible to this type. -``` +```scala implicit def list2ordered[A](x: List[A]) (implicit elem2ordered: A => Ordered[A]): Ordered[List[A]] = ... @@ -134,14 +134,14 @@ implicit def list2ordered[A](x: List[A]) Assume in addition a method -``` +```scala implicit def int2ordered(x: Int): Ordered[Int] ``` that injects integers into the `Ordered` class. We can now define a `sort` method over ordered lists: -``` +```scala def sort[A](xs: List[A])(implicit a2ordered: A => Ordered[A]) = ... ``` @@ -149,13 +149,13 @@ We can apply `sort` to a list of lists of integers `yss: List[List[Int]]` as follows: -``` +```scala sort(yss) ``` The call above will be completed by passing two nested implicit arguments: -``` +```scala sort(yss)(xs: List[Int] => list2ordered[Int](xs)(int2ordered)) . ``` @@ -164,7 +164,7 @@ raises the possibility of an infinite recursion. For instance, one might try to define the following method, which injects _every_ type into the `Ordered` class: -``` +```scala implicit def magic[A](x: A)(implicit a2ordered: A => Ordered[A]): Ordered[A] = a2ordered(x) ``` @@ -174,7 +174,7 @@ Now, if one tried to apply another injection into the `Ordered` class, one would obtain an infinite expansion: -``` +```scala sort(arg)(x => magic(x)(x => magic(x)(x => ... ))) ``` @@ -218,7 +218,7 @@ When typing `sort(xs)` for some list `xs` of type `List[List[List[Int]]]`, the sequence of types for which implicit arguments are searched is -``` +```scala List[List[Int]] => Ordered[List[List[Int]]], List[Int] => Ordered[List[Int]] Int => Ordered[Int] @@ -233,14 +233,14 @@ Hence, the code typechecks. Let `ys` be a list of some type which cannot be converted to `Ordered`. For instance: -``` +```scala val ys = List(new IllegalArgumentException, new ClassCastException, new Error) ``` Assume that the definition of `magic` above is in scope. Then the sequence of types for which implicit arguments are searched is -``` +```scala Throwable => Ordered[Throwable], Throwable => Ordered[Throwable], ... @@ -290,10 +290,10 @@ As for implicit parameters, overloading resolution is applied if there are several possible candidates (of either the call-by-value or the call-by-name category). -### Example: +### Example Class `scala.Ordered[A]` contains a method -``` +```scala def <= [B >: A](that: B)(implicit b2ordered: B => Ordered[B]): Boolean . ``` @@ -302,13 +302,13 @@ and assume that the `list2ordered` and `int2ordered` methods defined [here](#implicit-parameters) are in scope. Then the operation -``` +```scala xs <= ys ``` is legal, and is expanded to: -``` +```scala list2ordered(xs)(int2ordered).<= (ys) (xs => list2ordered(xs)(int2ordered)) @@ -322,7 +322,7 @@ method. ## Context Bounds and View Bounds -``` +```ebnf TypeParam ::= (id | ‘_’) [TypeParamClause] [‘>:’ Type] [‘<:’ Type] {‘<%’ Type} {‘:’ Type} ``` @@ -342,13 +342,13 @@ A method or class containing type parameters with view or context bounds is trea equivalent to a method with implicit parameters. Consider first the case of a single parameter with view and/or context bounds such as: -``` +```scala def $f$[$A$ <% $T_1$ ... <% $T_m$ : $U_1$ : $U_n$]($\mathit{ps}$): $R$ = ... ``` Then the method definition above is expanded to -``` +```scala def $f$[$A$]($\mathit{ps}$)(implicit $v_1$: $A$ => $T_1$, ..., $v_m$: $A$ => $T_m$, $w_1$: $U_1$[$A$], ..., $w_n$: $U_n$[$A$]): $R$ = ... ``` @@ -369,7 +369,7 @@ additional implicit parameters. The `<=` method from the [`Ordered` example](#example-ordered) can be declared more concisely as follows: -``` +```scala def <= [B >: A <% Ordered[B]](that: B): Boolean ``` @@ -382,7 +382,7 @@ standard library contains a hierarchy of four manifest classes, with `OptManifest` at the top. Their signatures follow the outline below. -``` +```scala trait OptManifest[+T] object NoManifest extends OptManifest[Nothing] trait ClassManifest[T] extends OptManifest[T] diff --git a/10-pattern-matching.md b/10-pattern-matching.md index cb20a81823d1..19182c757b47 100644 --- a/10-pattern-matching.md +++ b/10-pattern-matching.md @@ -8,7 +8,7 @@ chapter: 8 ## Patterns -``` +```ebnf Pattern ::= Pattern1 { ‘|’ Pattern1 } Pattern1 ::= varid ‘:’ TypePat | ‘_’ ‘:’ TypePat @@ -55,7 +55,7 @@ patterns. ### Variable Patterns -``` +```ebnf SimplePattern ::= `_' | varid ``` @@ -69,7 +69,7 @@ which is treated as if it was a fresh variable on each occurrence. ### Typed Patterns -``` +```ebnf Pattern1 ::= varid `:' TypePat | `_' `:' TypePat ``` @@ -83,7 +83,7 @@ that value. ### Pattern Binders -``` +```ebnf Pattern2 ::= varid `@' Pattern3 ``` @@ -95,7 +95,7 @@ and it binds the variable name to that value. ### Literal Patterns -``` +```ebnf SimplePattern ::= Literal ``` @@ -105,7 +105,7 @@ expected type of the pattern. ### Stable Identifier Patterns -``` +```ebnf SimplePattern ::= StableId ``` @@ -122,7 +122,7 @@ backquotes; then it is treated as a stable identifier pattern. ###### Example Consider the following function definition: -``` +```scala def f(x: Int, y: Int) = x match { case y => ... } @@ -132,7 +132,7 @@ Here, `y` is a variable pattern, which matches any value. If we wanted to turn the pattern into a stable identifier pattern, this can be achieved as follows: -``` +```scala def f(x: Int, y: Int) = x match { case `y` => ... } @@ -144,7 +144,7 @@ argument of `f` are equal. ### Constructor Patterns -``` +```ebnf SimplePattern ::= StableId `(' [Patterns] `) ``` @@ -170,7 +170,7 @@ repeated parameter. This is further discussed [here](#pattern-sequences). ### Tuple Patterns -``` +```ebnf SimplePattern ::= `(' [Patterns] `)' ``` @@ -181,7 +181,7 @@ where $n \geq 2$. The empty tuple ### Extractor Patterns -``` +```ebnf SimplePattern ::= StableId `(' [Patterns] `)' ``` @@ -221,7 +221,7 @@ This case is further discussed [below](#pattern-sequences). The `Predef` object contains a definition of an extractor object `Pair`: -``` +```scala object Pair { def apply[A, B](x: A, y: B) = Tuple2(x, y) def unapply[A, B](x: Tuple2[A, B]): Option[Tuple2[A, B]] = Some(x) @@ -232,7 +232,7 @@ This means that the name `Pair` can be used in place of `Tuple2` for tuple formation as well as for deconstruction of tuples in patterns. Hence, the following is possible: -``` +```scala val x = (1, 2) val y = x match { case Pair(i, s) => Pair(s + i, i * i) @@ -241,7 +241,7 @@ val y = x match { ### Pattern Sequences -``` +```ebnf SimplePattern ::= StableId `(' [Patterns `,'] [varid `@'] `_' `*' `)' ``` @@ -262,7 +262,7 @@ p_n$. ### Infix Operation Patterns -``` +```ebnf Pattern3 ::= SimplePattern {id [nl] SimplePattern} ``` @@ -277,7 +277,7 @@ shorthand for the constructor or extractor pattern $\mathit{op}(p, q_1 ### Pattern Alternatives -``` +```ebnf Pattern ::= Pattern1 { `|' Pattern1 } ``` @@ -320,7 +320,7 @@ A pattern $p$ is _irrefutable_ for a type $T$, if one of the following applies: ## Type Patterns -``` +```ebnf TypePat ::= Type ``` @@ -448,7 +448,7 @@ are inferred in the same way as for the typed pattern ###### Example Consider the program fragment: -``` +```scala val x: Any x match { case y: List[a] => ... @@ -464,7 +464,7 @@ bounds. The scope of `a` is right-hand side of its case clause. On the other hand, if `x` is declared as -``` +```scala val x: List[List[String]], ``` @@ -477,7 +477,7 @@ this generates the constraint ###### Example Consider the program fragment: -``` +```scala val x: Any x match { case y: List[String] => ... @@ -499,7 +499,7 @@ compiler will flag this potential loss of type-safety with an ###### Example Consider the program fragment -``` +```scala class Term[A] class Number(val n: Int) extends Term[Int] def f[B](t: Term[B]): B = t match { @@ -522,7 +522,7 @@ function's declared result type, `Number`. ## Pattern Matching Expressions -``` +```ebnf Expr ::= PostfixExpr `match' `{' CaseClauses `}' CaseClauses ::= CaseClause {CaseClause} CaseClause ::= `case' Pattern [Guard] `=>' Block @@ -530,7 +530,7 @@ function's declared result type, `Number`. A pattern matching expression -``` +```scala e match { case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ } ``` @@ -597,11 +597,11 @@ the compilation of pattern matching can emit warnings which diagnose that a given set of patterns is not exhaustive, i.e. that there is a possibility of a `MatchError` being raised at run-time. -### Example: +### Example Consider the following definitions of arithmetic terms: -``` +```scala abstract class Term[T] case class Lit(x: Int) extends Term[Int] case class Succ(t: Term[Int]) extends Term[Int] @@ -617,7 +617,7 @@ type of the expression it representes (either `Int` or `Boolean`). A type-safe evaluator for such terms can be written as follows. -``` +```scala def eval[T](t: Term[T]): T = t match { case Lit(n) => n case Succ(u) => eval(u) + 1 @@ -640,13 +640,13 @@ conforms to its expected type, `T`. ## Pattern Matching Anonymous Functions -``` +```ebnf BlockExpr ::= `{' CaseClauses `}' ``` An anonymous function can be defined by a sequence of cases -``` +```scala { case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ } ``` @@ -660,7 +660,7 @@ $R$ may be undetermined. If the expected type is `scala.Function$k$[$S_1 , \ldots , S_k$, $R$]`, the expression is taken to be equivalent to the anonymous function: -``` +```scala ($x_1: S_1 , \ldots , x_k: S_k$) => ($x_1 , \ldots , x_k$) match { case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ } @@ -671,7 +671,7 @@ As was shown [here](08-expressions.html#anonymous-functions), this anonymous fun equivalent to the following instance creation expression, where $T$ is the weak least upper bound of the types of all $b_i$. -``` +```scala new scala.Function$k$[$S_1 , \ldots , S_k$, $T$] { def apply($x_1: S_1 , \ldots , x_k: S_k$): $T$ = ($x_1 , \ldots , x_k$) match { case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ @@ -682,7 +682,7 @@ new scala.Function$k$[$S_1 , \ldots , S_k$, $T$] { If the expected type is `scala.PartialFunction[$S$, $R$]`, the expression is taken to be equivalent to the following instance creation expression: -``` +```scala new scala.PartialFunction[$S$, $T$] { def apply($x$: $S$): $T$ = x match { case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ @@ -704,7 +704,7 @@ Here is a method which uses a fold-left operation `/:` to compute the scalar product of two vectors: -``` +```scala def scalarProduct(xs: Array[Double], ys: Array[Double]) = (0.0 /: (xs zip ys)) { case (a, (b, c)) => a + b * c @@ -714,7 +714,7 @@ def scalarProduct(xs: Array[Double], ys: Array[Double]) = The case clauses in this code are equivalent to the following anonymous function: -``` +```scala (x, y) => (x, y) match { case (a, (b, c)) => a + b * c } diff --git a/11-top-level-definitions.md b/11-top-level-definitions.md index 2c65e358987f..cfb2c98adbfb 100644 --- a/11-top-level-definitions.md +++ b/11-top-level-definitions.md @@ -8,7 +8,7 @@ chapter: 9 ## Compilation Units -``` +```ebnf CompilationUnit ::= {‘package’ QualId semi} TopStatSeq TopStatSeq ::= TopStat {semi TopStat} TopStat ::= {Annotation} {Modifier} TmplDef @@ -25,7 +25,7 @@ package clause. A compilation unit -``` +```scala package $p_1$; $\ldots$ package $p_n$; @@ -36,7 +36,7 @@ starting with one or more package clauses is equivalent to a compilation unit consisting of the packaging -``` +```scala package $p_1$ { $\ldots$ package $p_n$ { $\mathit{stats}$ @@ -55,7 +55,7 @@ The exception to the implicit import of `scala.Predef` can be useful to hide, e. ## Packagings -``` +```ebnf Packaging ::= ‘package’ QualId [nl] ‘{’ TopStatSeq ‘}’ ``` @@ -74,7 +74,7 @@ Inside the packaging, all members of package $p$ are visible under their simple names. However this rule does not extend to members of enclosing packages of $p$ that are designated by a prefix of the path $p$. -``` +```scala package org.net.prj { ... } @@ -97,7 +97,7 @@ are visible to each other without qualification. ## Package Objects -``` +```ebnf PackageObject ::= ‘package’ ‘object’ ObjectDef ``` @@ -116,7 +116,7 @@ future version of Scala. ## Package References -``` +```ebnf QualId ::= id {‘.’ id} ``` @@ -131,7 +131,7 @@ outermost root package which contains all top-level packages. ###### Example Consider the following program: -``` +```scala package b { class B } @@ -168,7 +168,7 @@ which executes the initializaton code of the object $m$. The following example will create a hello world program by defining a method `main` in module `test.HelloWorld`. -``` +```scala package test object HelloWorld { def main(args: Array[String]) { println("Hello World") } @@ -177,13 +177,13 @@ object HelloWorld { This program can be started by the command -``` +```scala scala test.HelloWorld ``` In a Java environment, the command -``` +```scala java test.HelloWorld ``` @@ -192,7 +192,7 @@ would work as well. `HelloWorld` can also be defined without a `main` method by inheriting from `App` instead: -``` +```scala package test object HelloWorld extends App { println("Hello World") diff --git a/12-xml-expressions-and-patterns.md b/12-xml-expressions-and-patterns.md index 735349cb90b8..7aab3380d49a 100644 --- a/12-xml-expressions-and-patterns.md +++ b/12-xml-expressions-and-patterns.md @@ -18,7 +18,7 @@ XML expressions are expressions generated by the following production, where the opening bracket `<` of the first element must be in a position to start the lexical [XML mode](03-lexical-syntax.html#xml-mode). -``` +```ebnf XmlExpr ::= XmlContent {Element} ``` @@ -33,7 +33,7 @@ standard. Only the productions for attribute values and character data are chang Scala does not support declarations, CDATA sections or processing instructions. Entity references are not resolved at runtime. -``` +```ebnf Element ::= EmptyElemTag | STag Content ETag @@ -67,7 +67,7 @@ and consecutive occurrences of whitespace are replaced by a single space character `\u0020`. This behavior can be changed to preserve all whitespace with a compiler option. -``` +```ebnf Attribute ::= Name Eq AttValue AttValue ::= ‘"’ {CharQ | CharRef} ‘"’ @@ -88,7 +88,7 @@ within XML text as generated by CharData, it must be doubled. Thus, `{{` represents the XML text `{` and does not introduce an embedded Scala expression. -``` +```ebnf BaseChar, Char, Comment, CombiningChar, Ideographic, NameChar, S, Reference ::= $\mbox{\rm\em “as in W3C XML”}$ @@ -109,7 +109,7 @@ XML patterns are patterns generated by the following production, where the opening bracket `<` of the element patterns must be in a position to start the lexical [XML mode](03-lexical-syntax.html#xml-mode). -``` +```ebnf XmlPattern ::= ElementPattern ``` @@ -128,7 +128,7 @@ and consecutive occurrences of whitespace are replaced by a single space character `\u0020`. This behavior can be changed to preserve all whitespace with a compiler option. -``` +```ebnf ElemPattern ::= EmptyElemTagP | STagP ContentP ETagP diff --git a/13-user-defined-annotations.md b/13-user-defined-annotations.md index 621b55928d80..a9f3e0f1de02 100644 --- a/13-user-defined-annotations.md +++ b/13-user-defined-annotations.md @@ -6,7 +6,7 @@ chapter: 11 # User-Defined Annotations -``` +```ebnf Annotation ::= ‘@’ SimpleType {ArgumentExprs} ConstrAnnotation ::= ‘@’ SimpleType ArgumentExprs ``` @@ -26,7 +26,7 @@ does not matter. Examples: -``` +```scala @deprecated("Use D", "1.0") class C { ... } // Class annotation @transient @volatile var m: Int // Variable annotation String @local // Type annotation diff --git a/14-the-scala-standard-library.md b/14-the-scala-standard-library.md index db68edd32f5f..d0d06c25b2b3 100644 --- a/14-the-scala-standard-library.md +++ b/14-the-scala-standard-library.md @@ -40,7 +40,7 @@ class for objects). The signatures of these root classes are described by the following definitions. -``` +```scala package scala /** The universal root class */ abstract class Any { @@ -87,12 +87,11 @@ class AnyRef extends Any { def synchronized[T](body: => T): T // execute `body` in while locking `this`. } -``` - +```scala The type test `$x$.isInstanceOf[$T$]` is equivalent to a typed pattern match -``` +```scala $x$ match { case _: $T'$ => true case _ => false @@ -131,7 +130,7 @@ Subrange types, as well as `Int` and `Long` are called _integer types_, whereas Numeric value types are ranked in the following partial order: -``` +```scala Byte - Short \ Int - Long - Float - Double @@ -215,7 +214,7 @@ type. If this is true, it will perform the `==` operation which is appropriate for that type. That is, the `equals` method of a numeric value type can be thought of being defined as follows: -``` +```scala def equals(other: Any): Boolean = other match { case that: Byte => this == that case that: Short => this == that @@ -235,11 +234,11 @@ for type `Int` and for all subrange types. The `toString` method displays its receiver as an integer or floating point number. -### Example: +### Example This is the signature of the numeric value type `Int`: -``` +```scala package scala abstract sealed class Int extends AnyVal { def == (that: Double): Boolean // double equality @@ -292,7 +291,7 @@ Class `Boolean` has only two values: `true` and `false`. It implements operations as given in the following class definition. -``` +```scala package scala abstract sealed class Boolean extends AnyVal { def && (p: => Boolean): Boolean = // boolean and @@ -347,7 +346,7 @@ class of the underlying host system (and may be identified with it). For Scala clients the class is taken to support in each case a method -``` +```scala def + (that: Any): String ``` @@ -359,7 +358,7 @@ right operand. Scala defines tuple classes `Tuple$n$` for $n = 2 , \ldots , 22$. These are defined as follows. -``` +```scala package scala case class Tuple$n$[+T_1, ..., +T_n](_1: T_1, ..., _$n$: T_$n$) { def toString = "(" ++ _1 ++ "," ++ $\ldots$ ++ "," ++ _$n$ ++ ")" @@ -375,7 +374,7 @@ as an alias for `Tuple3`. Scala defines function classes `Function$n$` for $n = 1 , \ldots , 22$. These are defined as follows. -``` +```scala package scala trait Function$n$[-T_1, ..., -T_$n$, +R] { def apply(x_1: T_1, ..., x_$n$: T_$n$): R @@ -386,7 +385,7 @@ trait Function$n$[-T_1, ..., -T_$n$, +R] { The `PartialFunction` subclass of `Function1` represents functions that (indirectly) specify their domain. Use the `isDefined` method to query whether the partial function is defined for a given input (i.e., whether the input is part of the function's domain). -``` +```scala class PartialFunction[-A, +B] extends Function1[A, B] { def isDefinedAt(x: A): Boolean } @@ -401,7 +400,7 @@ All operations on arrays desugar to the corresponding operations of the underlying platform. Therefore, the following class definition is given for informational purposes only: -``` +```scala final class Array[T](_length: Int) extends java.io.Serializable with java.lang.Cloneable { def length: Int = $\ldots$ @@ -463,7 +462,7 @@ However, it is possible to cast an expression of type `Array[String]` to `Array[Object]`, and this cast will succeed without raising a `ClassCastException`. Example: -``` +```scala val xs = new Array[String](2) // val ys: Array[Object] = xs // **** error: incompatible types val ys: Array[Object] = xs.asInstanceOf[Array[Object]] // OK @@ -478,7 +477,7 @@ following implementation of method `mkArray`, which creates an array of an arbitrary type $T$, given a sequence of $T$`s which defines its elements: -``` +```scala import reflect.ClassTag def mkArray[T : ClassTag](elems: Seq[T]): Array[T] = { val result = new Array[T](elems.length) @@ -505,7 +504,7 @@ instantiation of single- and multi-dimensional arrays, an extractor method [`unapplySeq`](10-pattern-matching.html#extractor-patterns) which enables pattern matching over arrays and additional utility methods: -``` +```scala package scala object Array { /** copies array elements from `src` to `dest`. */ @@ -558,7 +557,7 @@ object Array { ## Class Node -``` +```scala package scala.xml trait Node { @@ -637,7 +636,7 @@ for Scala programs. It is always implicitly imported, so that all its defined members are available without qualification. Its definition for the JVM environment conforms to the following signature: -``` +```scala package scala object Predef { @@ -714,8 +713,7 @@ object Predef { ``` -``` - +```scala // tupling --------------------------------------------------------- type Pair[+A, +B] = Tuple2[A, B] diff --git a/15-syntax-summary.md b/15-syntax-summary.md index ac24e1e14a59..3eecc26eb417 100644 --- a/15-syntax-summary.md +++ b/15-syntax-summary.md @@ -10,14 +10,14 @@ The following descriptions of Scala tokens uses literal characters `‘c’` whe _Unicode escapes_ are used to represent the Unicode character with the given hexadecimal code: -``` +```ebnf UnicodeEscape ::= ‘\‘ ‘u‘ {‘u‘} hexDigit hexDigit hexDigit hexDigit hexDigit ::= ‘0’ | … | ‘9’ | ‘A’ | … | ‘F’ | ‘a’ | … | ‘f’ ``` The lexical syntax of Scala is given by the following grammar in EBNF form: -``` +```ebnf whiteSpace ::= ‘\u0020’ | ‘\u0009’ | ‘\u000D’ | ‘\u000A’ upper ::= ‘A’ | … | ‘Z’ | ‘\$’ | ‘_’ // and Unicode category Lu lower ::= ‘a’ | … | ‘z’ // and Unicode category Ll @@ -75,7 +75,7 @@ semi ::= ‘;’ | nl {nl} The context-free syntax of Scala is given by the following EBNF grammar. -``` +```ebnf Literal ::= [‘-’] integerLiteral | [‘-’] floatingPointLiteral | booleanLiteral diff --git a/_includes/numbering.css b/_includes/numbering.css index e8404652dcf2..86b946354d02 100644 --- a/_includes/numbering.css +++ b/_includes/numbering.css @@ -41,12 +41,12 @@ h3:before { margin-right: 1em; } -h3[id*='example:'] { +h3[id*='example'] { /* must increment here */ counter-increment: example; display: inline; } -h3[id*='example:']:before { +h3[id*='example']:before { /* and must reset again here */ counter-reset: chapter {{ page.chapter }}; diff --git a/_layouts/default.yml b/_layouts/default.yml index cb9f8623beaa..814bc511a9c4 100644 --- a/_layouts/default.yml +++ b/_layouts/default.yml @@ -21,7 +21,7 @@ From a0c3bbdb3a4b1055834f3ff5f729dc3af1867696 Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Thu, 27 Mar 2014 13:23:49 +0100 Subject: [PATCH 163/826] SI-8451 quasiquotes now handle quirks of secondary constructors Apparently even though the rhs of a secondary constructor looks like an expr, it always gets wrapped in a block by the parser. This works just fine with the typer, but crashes in uncurry. This commit brings quasiquotes in line with the parser. --- .../scala/reflect/internal/ReificationSupport.scala | 12 +++++++++++- .../quasiquotes/DefinitionConstructionProps.scala | 9 +++++++++ .../quasiquotes/DefinitionDeconstructionProps.scala | 6 ++++++ test/files/scalacheck/quasiquotes/ErrorProps.scala | 13 +++++++++++++ 4 files changed, 39 insertions(+), 1 deletion(-) diff --git a/src/reflect/scala/reflect/internal/ReificationSupport.scala b/src/reflect/scala/reflect/internal/ReificationSupport.scala index f9f93fbff053..37f7b857207a 100644 --- a/src/reflect/scala/reflect/internal/ReificationSupport.scala +++ b/src/reflect/scala/reflect/internal/ReificationSupport.scala @@ -523,11 +523,21 @@ trait ReificationSupport { self: SymbolTable => object SyntacticDefDef extends SyntacticDefDefExtractor { def apply(mods: Modifiers, name: TermName, tparams: List[Tree], vparamss: List[List[Tree]], tpt: Tree, rhs: Tree): DefDef = { + val tparams0 = mkTparams(tparams) val vparamss0 = mkParam(vparamss, PARAM) - DefDef(mods, name, mkTparams(tparams), vparamss0, tpt, rhs) + val rhs0 = { + if (name != nme.CONSTRUCTOR) rhs + else rhs match { + case Block(_, _) => rhs + case _ => Block(List(rhs), gen.mkSyntheticUnit) + } + } + DefDef(mods, name, tparams0, vparamss0, tpt, rhs0) } def unapply(tree: Tree): Option[(Modifiers, TermName, List[TypeDef], List[List[ValDef]], Tree, Tree)] = tree match { + case DefDef(mods, nme.CONSTRUCTOR, tparams, vparamss, tpt, Block(List(expr), Literal(Constant(())))) => + Some((mods, nme.CONSTRUCTOR, tparams, vparamss, tpt, expr)) case DefDef(mods, name, tparams, vparamss, tpt, rhs) => Some((mods, name, tparams, vparamss, tpt, rhs)) case _ => None diff --git a/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala b/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala index 69aef126685f..fd810674f536 100644 --- a/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala +++ b/test/files/scalacheck/quasiquotes/DefinitionConstructionProps.scala @@ -90,6 +90,15 @@ trait ClassConstruction { self: QuasiquoteProperties => val args = q"val a: Int; val b: Int" assertEqAst(q"class C(implicit ..$args)", "class C(implicit val a: Int, val b: Int)") } + + property("SI-8451: inline secondary constructors") = test { + assertEqAst(q"class C(x: Int) { def this() = this(0) }", "class C(x: Int) { def this() = this(0) }") + } + + property("SI-8451: unquoted secondary constructors") = test { + val secondaryCtor = q"def this() = this(0)" + assertEqAst(q"class C(x: Int) { $secondaryCtor }", "class C(x: Int) { def this() = this(0) }") + } } trait TraitConstruction { self: QuasiquoteProperties => diff --git a/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala b/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala index af7f2164a0a3..2c0e100b5a7d 100644 --- a/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala +++ b/test/files/scalacheck/quasiquotes/DefinitionDeconstructionProps.scala @@ -229,6 +229,12 @@ trait DefDeconstruction { self: QuasiquoteProperties => val q"def foo(...$argss)(implicit ..$impl)" = q"def foo(x: Int)" assert(impl.isEmpty) } + + property("SI-8451") = test { + val q"def this(..$params) = this(..$args)" = q"def this(x: Int) = this(0)" + assert(params ≈ List(q"${Modifiers(PARAM)} val x: Int")) + assert(args ≈ List(q"0")) + } } trait ImportDeconstruction { self: QuasiquoteProperties => diff --git a/test/files/scalacheck/quasiquotes/ErrorProps.scala b/test/files/scalacheck/quasiquotes/ErrorProps.scala index 9137fe17d869..2cba07abf2df 100644 --- a/test/files/scalacheck/quasiquotes/ErrorProps.scala +++ b/test/files/scalacheck/quasiquotes/ErrorProps.scala @@ -195,6 +195,19 @@ object ErrorProps extends QuasiquoteProperties("errors") { q"f(..$l)" """) + property("SI-8451 construction: disallow everything except for constructor calls in secondary constructor bodies") = fails( + "'this' expected but unquotee found", + """ + val rhs1 = q"this(0)" + val ctor1 = q"def this(x: Int) = $rhs1" + """) + + property("SI-8451 deconstruction: disallow everything except for constructor calls in secondary constructor bodies") = fails( + "'this' expected but unquotee found", + """ + val q"def this(..$params) = $rhs2" = q"def this(x: Int) = this(0)" + """) + // // Make sure a nice error is reported in this case // { import Flag._; val mods = NoMods; q"lazy $mods val x: Int" } } From 0261598fb49f4ac0509dac0c27f867861dc742a0 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Wed, 26 Mar 2014 21:59:30 -0700 Subject: [PATCH 164/826] Jekyll generated html in spec/ directory To avoid confusion, removing artifacts for currently unsupported targets (pdf/single-page html). I'd like to bring those back, but in the mean time let's avoid distractions. Add Travis build. --- .travis.yml | 7 + 16-references.md | 12 - Gemfile | 7 + LICENSE_HEURISTICA | 101 -------- LICENSE_LUXIMONO | 15 -- Makefile | 147 ----------- resources/Heuristica-Bold.woff | Bin 106188 -> 0 bytes resources/Heuristica-BoldItalic.woff | Bin 104316 -> 0 bytes resources/Heuristica-Regular.woff | Bin 141416 -> 0 bytes resources/Heuristica-RegularItalic.woff | Bin 104700 -> 0 bytes resources/LuxiMono-Bold.woff | Bin 26560 -> 0 bytes resources/LuxiMono-BoldOblique.woff | Bin 29480 -> 0 bytes resources/LuxiMono-Regular.woff | Bin 26432 -> 0 bytes resources/LuxiMono-RegularOblique.woff | Bin 29300 -> 0 bytes resources/ScalaReference.js | 20 -- resources/blueprint-print.css | 29 --- resources/blueprint-screen.css | 231 ------------------ resources/fonts.css | 57 ----- resources/grid.png | Bin 104 -> 0 bytes resources/ie.css | 36 --- resources/scala-ref-template.html5 | 81 ------ resources/scala-ref-template.latex | 164 ------------- resources/style.css | 93 ------- 01-title.md => spec/01-title.md | 0 02-preface.md => spec/02-preface.md | 0 .../03-lexical-syntax.md | 0 .../04-identifiers-names-and-scopes.md | 0 05-types.md => spec/05-types.md | 0 .../06-basic-declarations-and-definitions.md | 0 .../07-classes-and-objects.md | 0 08-expressions.md => spec/08-expressions.md | 0 .../09-implicit-parameters-and-views.md | 0 .../10-pattern-matching.md | 0 .../11-top-level-definitions.md | 0 .../12-xml-expressions-and-patterns.md | 0 .../13-user-defined-annotations.md | 0 .../14-the-scala-standard-library.md | 2 +- .../15-syntax-summary.md | 0 Scala.bib => spec/16-references.md | 46 ++-- README.md => spec/README.md | 0 _config.yml => spec/_config.yml | 2 +- {_includes => spec/_includes}/numbering.css | 0 {_layouts => spec/_layouts}/default.yml | 3 +- index.md => spec/index.md | 0 .../public/images}/classhierarchy.pdf | Bin .../public/stylesheets/screen.css | 8 +- test.html | 8 - 47 files changed, 53 insertions(+), 1016 deletions(-) create mode 100644 .travis.yml delete mode 100644 16-references.md create mode 100644 Gemfile delete mode 100644 LICENSE_HEURISTICA delete mode 100644 LICENSE_LUXIMONO delete mode 100644 Makefile delete mode 100644 resources/Heuristica-Bold.woff delete mode 100644 resources/Heuristica-BoldItalic.woff delete mode 100644 resources/Heuristica-Regular.woff delete mode 100644 resources/Heuristica-RegularItalic.woff delete mode 100644 resources/LuxiMono-Bold.woff delete mode 100644 resources/LuxiMono-BoldOblique.woff delete mode 100644 resources/LuxiMono-Regular.woff delete mode 100644 resources/LuxiMono-RegularOblique.woff delete mode 100644 resources/ScalaReference.js delete mode 100755 resources/blueprint-print.css delete mode 100644 resources/blueprint-screen.css delete mode 100644 resources/fonts.css delete mode 100755 resources/grid.png delete mode 100755 resources/ie.css delete mode 100644 resources/scala-ref-template.html5 delete mode 100644 resources/scala-ref-template.latex delete mode 100644 resources/style.css rename 01-title.md => spec/01-title.md (100%) rename 02-preface.md => spec/02-preface.md (100%) rename 03-lexical-syntax.md => spec/03-lexical-syntax.md (100%) rename 04-identifiers-names-and-scopes.md => spec/04-identifiers-names-and-scopes.md (100%) rename 05-types.md => spec/05-types.md (100%) rename 06-basic-declarations-and-definitions.md => spec/06-basic-declarations-and-definitions.md (100%) rename 07-classes-and-objects.md => spec/07-classes-and-objects.md (100%) rename 08-expressions.md => spec/08-expressions.md (100%) rename 09-implicit-parameters-and-views.md => spec/09-implicit-parameters-and-views.md (100%) rename 10-pattern-matching.md => spec/10-pattern-matching.md (100%) rename 11-top-level-definitions.md => spec/11-top-level-definitions.md (100%) rename 12-xml-expressions-and-patterns.md => spec/12-xml-expressions-and-patterns.md (100%) rename 13-user-defined-annotations.md => spec/13-user-defined-annotations.md (100%) rename 14-the-scala-standard-library.md => spec/14-the-scala-standard-library.md (99%) rename 15-syntax-summary.md => spec/15-syntax-summary.md (100%) rename Scala.bib => spec/16-references.md (85%) rename README.md => spec/README.md (100%) rename _config.yml => spec/_config.yml (95%) rename {_includes => spec/_includes}/numbering.css (100%) rename {_layouts => spec/_layouts}/default.yml (88%) rename index.md => spec/index.md (100%) rename {resources => spec/public/images}/classhierarchy.pdf (100%) rename resources/github.css => spec/public/stylesheets/screen.css (96%) delete mode 100644 test.html diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 000000000000..0bfd06e15128 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,7 @@ +# based on http://www.paperplanes.de/2013/8/13/deploying-your-jekyll-blog-to-s3-with-travis-ci.html +language: ruby +rvm: + - 1.9.3 +script: bundle exec jekyll build -s spec/ -d build/spec +install: bundle install +# after_success: bundle exec s3_website push --headless \ No newline at end of file diff --git a/16-references.md b/16-references.md deleted file mode 100644 index d0410e748a72..000000000000 --- a/16-references.md +++ /dev/null @@ -1,12 +0,0 @@ ---- -title: References -layout: default -chapter: 14 ---- - - -# References - - \ No newline at end of file diff --git a/Gemfile b/Gemfile new file mode 100644 index 000000000000..53924a4381bd --- /dev/null +++ b/Gemfile @@ -0,0 +1,7 @@ +# To build the spec on Travis CI +source "https://rubygems.org" + +gem "jekyll", "2.0.0.alpha.2" +gem "rouge" +# gem 's3_website' +# gem 'redcarpet' diff --git a/LICENSE_HEURISTICA b/LICENSE_HEURISTICA deleted file mode 100644 index 9693dc1db2df..000000000000 --- a/LICENSE_HEURISTICA +++ /dev/null @@ -1,101 +0,0 @@ -Copyright 1989, 1991 Adobe Systems Incorporated. All rights reserved. -Utopia is either a registered trademark or trademark of Adobe Systems -Incorporated in the United States and/or other countries. Used under -license. - -Copyright 2006 Han The Thanh, Vntopia font family, http://vntex.sf.net - -Copyright (c) 2008-2012, Andrey V. Panov (panov@canopus.iacp.dvo.ru), -with Reserved Font Name Heuristica. - -This Font Software is licensed under the SIL Open Font License, Version 1.1. -This license is copied below, and is also available with a FAQ at: -http://scripts.sil.org/OFL - - ------------------------------------------------------------ -SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 ------------------------------------------------------------ - -PREAMBLE -The goals of the Open Font License (OFL) are to stimulate worldwide -development of collaborative font projects, to support the font creation -efforts of academic and linguistic communities, and to provide a free and -open framework in which fonts may be shared and improved in partnership -with others. - -The OFL allows the licensed fonts to be used, studied, modified and -redistributed freely as long as they are not sold by themselves. The -fonts, including any derivative works, can be bundled, embedded, -redistributed and/or sold with any software provided that any reserved -names are not used by derivative works. The fonts and derivatives, -however, cannot be released under any other type of license. The -requirement for fonts to remain under this license does not apply -to any document created using the fonts or their derivatives. - -DEFINITIONS -"Font Software" refers to the set of files released by the Copyright -Holder(s) under this license and clearly marked as such. This may -include source files, build scripts and documentation. - -"Reserved Font Name" refers to any names specified as such after the -copyright statement(s). - -"Original Version" refers to the collection of Font Software components as -distributed by the Copyright Holder(s). - -"Modified Version" refers to any derivative made by adding to, deleting, -or substituting -- in part or in whole -- any of the components of the -Original Version, by changing formats or by porting the Font Software to a -new environment. - -"Author" refers to any designer, engineer, programmer, technical -writer or other person who contributed to the Font Software. - -PERMISSION & CONDITIONS -Permission is hereby granted, free of charge, to any person obtaining -a copy of the Font Software, to use, study, copy, merge, embed, modify, -redistribute, and sell modified and unmodified copies of the Font -Software, subject to the following conditions: - -1) Neither the Font Software nor any of its individual components, -in Original or Modified Versions, may be sold by itself. - -2) Original or Modified Versions of the Font Software may be bundled, -redistributed and/or sold with any software, provided that each copy -contains the above copyright notice and this license. These can be -included either as stand-alone text files, human-readable headers or -in the appropriate machine-readable metadata fields within text or -binary files as long as those fields can be easily viewed by the user. - -3) No Modified Version of the Font Software may use the Reserved Font -Name(s) unless explicit written permission is granted by the corresponding -Copyright Holder. This restriction only applies to the primary font name as -presented to the users. - -4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font -Software shall not be used to promote, endorse or advertise any -Modified Version, except to acknowledge the contribution(s) of the -Copyright Holder(s) and the Author(s) or with their explicit written -permission. - -5) The Font Software, modified or unmodified, in part or in whole, -must be distributed entirely under this license, and must not be -distributed under any other license. The requirement for fonts to -remain under this license does not apply to any document created -using the Font Software. - -TERMINATION -This license becomes null and void if any of the above conditions are -not met. - -DISCLAIMER -THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT -OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE -COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, -INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL -DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM -OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/LICENSE_LUXIMONO b/LICENSE_LUXIMONO deleted file mode 100644 index 2f480f664e9c..000000000000 --- a/LICENSE_LUXIMONO +++ /dev/null @@ -1,15 +0,0 @@ -Luxi fonts copyright (c) 2001 by Bigelow & Holmes Inc. Luxi font instruction code copyright (c) 2001 by URW++ GmbH. All Rights Reserved. Luxi is a registered trademark of Bigelow & Holmes Inc. - -Permission is hereby granted, free of charge, to any person obtaining a copy of these Fonts and associated documentation files (the "Font Software"), to deal in the Font Software, including without limitation the rights to use, copy, merge, publish, distribute, sublicense, and/or sell copies of the Font Software, and to permit persons to whom the Font Software is furnished to do so, subject to the following conditions: - -The above copyright and trademark notices and this permission notice shall be included in all copies of one or more of the Font Software. - -The Font Software may not be modified, altered, or added to, and in particular the designs of glyphs or characters in the Fonts may not be modified nor may additional glyphs or characters be added to the Fonts. This License becomes null and void when the Fonts or Font Software have been modified. - -THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL BIGELOW & HOLMES INC. OR URW++ GMBH. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER DEALINGS IN THE FONT SOFTWARE. - -Except as contained in this notice, the names of Bigelow & Holmes Inc. and URW++ GmbH. shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Font Software without prior written authorization from Bigelow & Holmes Inc. and URW++ GmbH. - -For further information, contact: - -info@urwpp.de or design@bigelowandholmes.com \ No newline at end of file diff --git a/Makefile b/Makefile deleted file mode 100644 index 3e0c90f74fee..000000000000 --- a/Makefile +++ /dev/null @@ -1,147 +0,0 @@ -MD_SOURCES := 01-title.md \ - 02-preface.md 03-lexical-syntax.md \ - 04-identifiers-names-and-scopes.md \ - 05-types.md \ - 06-basic-declarations-and-definitions.md \ - 07-classes-and-objects.md \ - 08-expressions.md \ - 09-implicit-parameters-and-views.md \ - 10-pattern-matching.md \ - 11-top-level-definitions.md \ - 12-xml-expressions-and-patterns.md \ - 13-user-defined-annotations.md \ - 14-the-scala-standard-library.md \ - 15-scala-syntax-summary.md \ - 16-references.md - -BUILD_DIR := build - -.PHONY: dirs all html mathml pdf tex epub2 epub3 md clean - - -all: html mathml pdf tex epub2 epub3 md - - -clean: - rm -rf $(BUILD_DIR) - - -html: $(BUILD_DIR)/ScalaReference.html - - -mathml: $(BUILD_DIR)/ScalaReference-mathml.html - - -pdf: $(BUILD_DIR)/ScalaReference.pdf - - -tex: $(BUILD_DIR)/ScalaReference.tex - - -epub2: $(BUILD_DIR)/ScalaReference.epub2 - - -epub3: $(BUILD_DIR)/ScalaReference.epub3 - - -md: $(BUILD_DIR)/ScalaReference.md - - -$(BUILD_DIR)/ScalaReference.epub2: Scala.bib $(BUILD_DIR)/ScalaReference.md - @echo "building EPUB2 spec to $(BUILD_DIR)/ScalaReference.epub2" - @pandoc -f markdown \ - -t epub \ - --standalone \ - --toc \ - --chapters \ - --number-sections \ - --bibliography=Scala.bib \ - --self-contained \ - -o build/ScalaReference.epub2 \ - build/ScalaReference.md - - -$(BUILD_DIR)/ScalaReference.epub3: Scala.bib $(BUILD_DIR)/ScalaReference.md - @echo "building EPUB3 spec to $(BUILD_DIR)/ScalaReference.epub3" - @pandoc -f markdown \ - -t epub3 \ - --standalone \ - --toc \ - --chapters \ - --number-sections \ - --bibliography=Scala.bib \ - --self-contained \ - -o build/ScalaReference.epub3 \ - build/ScalaReference.md - - -$(BUILD_DIR)/ScalaReference.pdf: Scala.bib $(BUILD_DIR)/ScalaReference.md - @echo "building PDF spec to $(BUILD_DIR)/ScalaReference.pdf" - @pandoc -f markdown \ - --standalone \ - --toc \ - --chapters \ - --number-sections \ - --bibliography=Scala.bib \ - --self-contained \ - --latex-engine=xelatex \ - --template=resources/scala-ref-template.latex \ - -o build/ScalaReference.pdf \ - build/ScalaReference.md - -$(BUILD_DIR)/ScalaReference.tex: Scala.bib $(BUILD_DIR)/ScalaReference.md - @echo "building LaTeX source to $(BUILD_DIR)/ScalaReference.tex" - @pandoc -f markdown \ - --standalone \ - --toc \ - --chapters \ - --number-sections \ - --bibliography=Scala.bib \ - --self-contained \ - --latex-engine=xelatex \ - --template=resources/scala-ref-template.latex \ - -o build/ScalaReference.tex \ - build/ScalaReference.md - - -$(BUILD_DIR)/ScalaReference.html: Scala.bib $(BUILD_DIR)/ScalaReference.md - @echo "building HTML spec to $(BUILD_DIR)/ScalaReference.html" - @pandoc -f markdown \ - -t html5 \ - --standalone \ - --toc \ - --chapters \ - --number-sections \ - --bibliography=Scala.bib \ - --template=resources/scala-ref-template.html5 \ - --mathjax='http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML' \ - -o build/ScalaReference.html \ - build/ScalaReference.md - -$(BUILD_DIR)/ScalaReference-mathml.html: Scala.bib $(BUILD_DIR)/ScalaReference.md - @echo "building HTML spec to $(BUILD_DIR)/ScalaReference-mathml.html" - @pandoc -f markdown \ - -t html5 \ - --standalone \ - --toc \ - --chapters \ - --number-sections \ - --bibliography=Scala.bib \ - --template=resources/scala-ref-template.html5 \ - --mathml \ - -o build/ScalaReference-mathml.html \ - build/ScalaReference.md - - -$(BUILD_DIR)/ScalaReference.md: dirs $(MD_SOURCES) - @echo "building Markdown source to $(BUILD_DIR)/ScalaReference.md" - @cat $(MD_SOURCES) > $(BUILD_DIR)/ScalaReference.md - - -dirs: $(BUILD_DIR) - - -$(BUILD_DIR): - mkdir -p $(BUILD_DIR) - cp -R resources $(BUILD_DIR)/resources - diff --git a/resources/Heuristica-Bold.woff b/resources/Heuristica-Bold.woff deleted file mode 100644 index 904579683d54e3e033fe1180b36fe9e1a5dba551..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 106188 zcmZs?1z1~6+qR3-0)GQtNx4(b? zo7{7)d(OFLt(D12GHW>EDkmxm1q}rS1)Vttg#p>ZzWw;84oUyNf1;wwG7w`igcJNN zT9{6zV!|S#5Y`8&Cqv4VkUqbgn7o`46cmg$6qG0~6x0^=j-9HQn39Sh6qL9d#QO$0 z2)T}ror9bb12YtqB!od}K#IOewu+9Cje$Lc%|b!JO+i5+V(|t$el~LX@dXM>E+68N z{aa9kkq}Mo&1@j-7IGZO@nMbNF1=yQ44fc+6?q|^cmFLP&8*!`Axszwnt~1rrfrpK z%y`4x#K0H|+Vuy-!vZPn&#f{c<`4*Bf1eu(q>v*NB9@uk{BVP?G01uNLqUCfb!{Qn zv9>dU_VpwPb|(DNJH7`WL(LI382^!xI+z=y*u+Zx!IK$tq@{AwVl6T4`z zooa9A1R2{16v)1wp`a+zgER2#>>W)YeKY@_Z#!gcP{lD_j$BO)O(E>>m?Hcwvq}nI zA=|&N64V$Vck=JH`?u8K-|e{cuSvIMiU}!HXa!8TsnUDPaA+ZeZI;XT2FR`0*>rKg z;1AJ7myy){^s1phE0(0)oM-TU{60MHaEVeJpx#PT{<5rZc9F69G}p-m?HcUH2`$%t z+Jterg<{+T_mk?tWnfI#-s*stv{v6B%dL^&cXmFrKXoZ-X<-nDOv7m-w~HD;?+I^F zDB`r{D@d7&^!ACZ%NN-1Obl>aKFdIMQ=V(NUs%ULXS(Ej6!AAXN<+|=w zcC6*p+w))lEV9e1l3}Ci6<0edO~T6=D0U!NQ&y=kEybVHX49inzAq^# zRjrUOo3*?P_YmmFpD&X+cD_sWP;;NNi$^E6JkKtVcl3LJHt}^L-1~m>e#BN0m6c<( z3ZH<&Gx8t>C{vMOPMLUmp;^45h-yz4n~6I^L}L;WUq`Ul6klVPbz-aGNVT^!GcQF- zXB2itU(`N+S*kQsIy0e`a+`YVfnM>-BXuYG)z#m#D?lGt9aYu8NPy6dsQumiPc;G9 zMVLnaGkwa-pJ?4;n?_Sex!E#dL_ZKyzUWC!gjfzsaD5+nRYZ-iP0IsxDMUKd-w>Qp z5{}+;Y+z}0(#?4D%&~0h?{#`dQV`o+RMD1SQmgH~ORxpWY-Ds&c4(B`>OWG(XBA#3 zQIpZ-iHW+18Xz!_9mY*(Iob~}jws+7v3xa_o=6t;6dkZ0;ljQ7b}^(b?e05379VBC z8*`;RkQ#nqzF^ia*g|5&vWJgLG-89x^9`Tn8CO;G3z;xaEV@!L1BR?wq1nD7mRT#+ zlPT&LK`a-q6YCi=Go_;JaJsC!%>G?UlkvQ9?#h@a^R)GTt@Leb3-isF-sAwAJ=)3cTF16 zBmb}nSyEa2B<@cHQ2$#Dyd8;uC;zyHp-(Vq)46zWu3LoCE+@u)UL;r(0 zInWMLBaV#{y%swN6TO}me~tHIjrEm*P#^_y#O_84q=|S8;vT($H2#5fd3%63fb@_? zj@`VN=L!h&HG}xy7$L|v9pcY>FwgIz{f-Tv0)LpBZ3f-??NH5+9w`VbJItR6g7g(3 zsF)sN;P{IkAZW7_=7)m37R06c8G_7^rbN1>{#unFR<|-JI!rg@DZ%b@f52ln(xo7L zH%z;HcM-f>PEUOgQT$S1V0;JilRSulpgf6I7&|ZzXm9dNcGSi3J>#0bEOrm(3uL0D{$Jro$E?_QB5$MOK9k> zMmfq~$&aA-gNwHv{z}PTN%<=+e%K?%+Gn%{=$1&}E^q^1NV-aggKGnX4Maw7}8He$sbGd7}9Sz=r0n5pe0oZ!h@ht6-XjTfj)vm zS>fSwk|LY3QkOilR>!c{l_~Ts_@12mwmqA&amq<@^2lQnP!)6SL1h}kc&@MKD zSfKrN&yh+^@}WN7S&@%nFHBLA_voQC{)3`zjAL2+O2H~sf!qjM!L#^CRDpE@Gj)Mm zyYBXthjS9M(ufz8r=$kG2|pF01efv%x?*IEV|sjCemb>DLp)1CyTV9|;zW{TPW-(@ zi}Hvjm6~{qE?$6&KjvDA z>i(#CdklZL?*l+9QkEr(o@6Csp=wzdrI8~ly+13+D?t3oAADB zWK(6y$%L`=G=X_bF~z<_x>@8k?%5Z5d2m@%0XqpA;}_z46R$l-0x9=;;vC%+J8KDo;ujKn zBd)PW4MZNw_AYb0q`17kZRnyBk9b3B&v}klc6-|!BmKaHFyFF|w#r=*zsHbxwL~V7 zyfj6CNa_kq^@3n|5}$IxXZ1jE4bro^h%Q(%aPx&1&^)Ix~J;6v|`I=Ig zDwQi~_}9|y0wi9Q{=(l2xbP=CjNwd*kqbLSM(ueWn#=q#pp2PLrDY=mtB9D)?inK5 zGqxEY(PcS_C#tnX1*6jV%<-A^uTtw|kT^4#A^Lh&F|$s6)<2_5dsZ;hD0PHOai$Qe zw*%lgn~VW{v51NWy|eIDT6Q^#?uE19kZe;}#vphhD*z}in@K#;T2#flnB>kHDeb^m z=w%PSi3Zh==D!hG+{eF?T2PJ{zLbTxeIV2F8Bb(kHmRtY;a9yc^N7jONj+3H8HzO< zWroD$aMk3n3++*pF%L!oKw-H^f=2@i!|VRtaCV>%aV@jJI1CfEe`TC2O;Uubmo@%q@`Ilft=ZyNu-Mm53C7pnw^Ji z=^qecB#2wg6Sjb{uNd2cGTGurzHv(930BNAAmArYtGVx&y&#v!;dyQ=-%ax>r+N-f zuZc+dWn#`{{AFB|N5V4>0+g09l3+@L7b$|5G^JNYgV9Dc%#7tm+QH~kz1_pNu4(?! zX<+v>u)g=YvB(*4w7F%1YQevCsJDH%(avv|v0MXis_9J~7y@N1*S|Cp0MBg3-t2D| zI3E|d9?iHO^{nq7dQ?`FT734ZV@3(e-Fl{hebYd9-!w^3m|1mR&|(IdyFoT`BNERr zt#Q!FCP$mvXEKt|kg9P5qk`fo>&NX$g-kq)BzPb{Fw(jD>b;n6M4oS5-kYu1n_Ysz zI<=;ojK_Kc-Aau_p%gC@bB0Cd+Hw zfaiqZC5h`X%l?+Z;nvROw#wm_gXhtT@C9fSRoa8WLz?Vs53V;sO>+h<)Qf4wq!Ci} z4aB{$MZR(nyvT7sE)|a1;)}X+O&Cs3z#NstfbM2Gms0G+S8ypZxB^(#z2~M`baziL zd#P;sTY$mROlB5{zRB@haZgX&ci3X_^<)``qo9M_s{9Q4GyMgZ0g9FSI(VC+0kwi6 z<-}8ZMMq5yM=NAPtrd@tPm)A)d69X`ThY=LLd-xw2%@YAlBgK|x@Gsw$ zhNhzt)3*An{J?o`+S{hcSBl8jal{(`%5thBk*w8?u=Au9PO@f}FniIl{5kFY>O!_N z?$1$=YB9Zffg*vmUO6m^L(ITL6CZ|`CdyiYVY=R#H*Af8ZqYjqji%We@2c{XSZ7c2 zMuxLKke*&0T)Jkjvt=K$uV)1&?-bPZR+{6T>7&y0HPkOh$){C^L z;~P4Iu{$neN%JlLw-+?-$CW<*MJ$q+EJZnnVjT6QASmKxaK zGhq^wfr?)pWAA2&6G8dH#?s(=;b)m4`H^1>GJSi)kzQ=w-*9{rSykdM(%d7r4Vk}@SeIqVN{b=vS{;C=o&z!|Dw;4;|A zr9kW2vFK)~tZ2t#AVD1_B}|-jyAUGMR!>)VPOG7|;v8yQR$ULIoCip(u$|#q0Apqx z1r6U%Mqj?~uRX6S0O-ws&idZ=HGyOjTQ0$<(Y!MLtJF&y4h=q*fp^3@doQ{Ik{MU;bSOJpN}heYEipfK@_(r8Itj8<#^ zvV#qEOueHS!)D%sQ7YROYOzf0TgqhSSU?|pqKNp2?Db9cm8`B5LIaRRwS zT1ocsF_vVv7leJ8(<&^o0`2c)JXkzMbITetS|}V_=$Ap-(Z)j{-k_za?)A8()4WLQ zdEa;cyzNlu8J;A^QWl-$Yr_G)q@zFPF2>R`@-~fC+pXWqIhn#tMwgaktCy*^cF}#d z7q2PL+#7mfm5KBdhR4pVBFAiW5X&4q7>h*HZ-^$Cd}`mUB3}_qO1F+#3+_2|$5jDy zdB^yc$&ZDa1)`-Fr59z$DuiSMp~qs!l*fv9N(}-sO89fYvXo=z>wf%Mtz-T+L>2@lKSeAIpa;AP}AX)f9yhlu9umUzfx++q_!N z9E`8WA(l)Qt~JiIk7L;Pun#|AvoEqQyyJ4ieIsi0(>=JQOWl~B$tt34+%A;T1O2Z=(M(_sgKnPd8G7LifKos z0Cb!yiBoMCq$-of9Tz+nCdc`PuJZd{ga%M|gc1@GGZL#-E%q#mN=E8S>q9O5xRXpE zixDY7oh!vWLvRn-l;03vy1p=ChC>;3aWcNQk%6Dn|Jsahj+}vpRXh1aKFWqdn4~&H zTb3!*?Hhot{zg$vWDQdl(A3q|h3o_C5&+1?h3lr=RH~LsF~vKCt`#6T{J^PK$B%;& zg#I83O&Z7rEsgM}3x)BiczuqQ^|gGxHXc?bMOSp>=M_*9RTVyd8@QuXK!6j)Ir5g^ z*uj?xMz9#XyDE07u14#dNH@vLJ3HB4P+Ruo+u*6>Yy=)P#>4LTMjP2Cy42MJ$$&oP z;d($x#$;*^LYOn_^02xbXTC#qmGi( z%-@uc<%dtIz=D^B3$=QG$)>vC4`qZ{xQ$homMYG3cPdfJ9rB+ED}(NF*3*D_ z^-mwF@QI!*ABU_&CrW-trt=@SIMH)ba&o)gIvtpzhNY*uucw!m7&-kcvOIpcSCQ$^ zUxddmEoG1fR)czq=*tO{kc$WJ3Eq^E?o_7VBj3G+Su%KZlzJEnsVEz{MTK2tvD(dy zNZio78(&LCNF7A9iyBE@jIyhUWF)sfT&pA@PP~`3>NLz5_?#9bQn{%3d2W!kVLwZmz5>cY&9g*73}#my~5AwZT2nb$);8V#4SCQDP3?)~&#! zSEj{D)qJ(RlDgDEim|4l#q=(yir+`}a&^poya@zs0L^1tw$9yFmQ-DBsCusaegGVx zrBuBEIDFU6$ZYj^eP0QUuvc63M>CpMReTm$u1BBS8aEoAD%Wlf(86fbJF8s`)_V3u zEES?e0=lL|Txm5Mift8ow{gR)E{KG=jCR>HA6?Oao=a<^7d}_#Q-G!W@|FV*m1)nS z)u*10lXDT>d(C^%^U+=3x2MF7`(y9Xq+R-yI^&1f&6k^tw{chuB6aVJlgDOax1F4I zG#R(z`x$KF;}>yL6=$)Kpsu{7I(CLO)A{{D-Exn7P`BL}cwoD<7$XYEs7t32A!qj6epA*QclMiZsLSl+ydO5{pRV^6HlVtyxRI(Pp|N5M>B&Pl39qyX5BxiQk=J7Gj;23zUpoih+85V8HQHa}e=sSmp7P)EFU_P%bIY#{i;Q#tK06we*s zx`}5%Pavr13wxE}QO%ft$6J{-f1HT0Q`p&IVuQ}|K~H{1zkfkfTy*o4P+z6EHjDDw znF_25y^voRz@MXSWYJ3ah6V(Ry|MfFW_j@3`O15i_{wwycu<-fa}h6o;DZD1G;IX% z_X!0-kGb{PD-%q3U!~0T5K6n9pIu;^->;(VPrK5L&dG0xdQ*;Wh>ATu0mP>L@ZotaW|}7a&_q7F568+Vt)Xw(a)&wEMO(xU23SntB|sg zRHq+z`TGPqFUlNhzKkE!(Kn9q`s~aU(F*y(Jl@@@6$dM3MeGOH$bP=FKdw@Y$|l0K zvyb?F;n(q@a(eb)ps8h`58vR5eL?;Bri3B8GungT&h7a9EOyO#|7I*0Yr(jYO(dbY z(BDFz`>8F~q%_c`On=4W4ksL`rx*+8^DhN~WXzuu3I+F{9V?pfgNFRih=J z3$9mMb<_HxXb*KcV>IJ>eefde^1?26B|%>3-Bget^zjjYLAk4&om8kQ@X34>n`MxH zOK#14q?~0?e8bFGkK72|ay0~J;P_A?&}bS63wuej`C9Qa(-6tm?RXjp(7cibU4(3L z7=pub%0s$-zxzizNrS3FwrC8&zmv~s47X`Ki0kd9d<33;`CR!ied%1_gst{{ z{x1Fey$7-H5}FBT8i@?De>hQLNM!}FuMcrmwgbwXKl&270_>Lz_6y#DhIo)ktG~ef z6@Qz->a%2<6{Z>+4ri`I*hd(fx@Fyl3fV|RZKZ8b9i?to`SA_4L9JwNwyirjTZ8vem$jb51h{P5 zFmCB7vsfx;$hacP;@K}-mFErH9165UfLs{gXG9ykzgjC z1|pfQX-p!Seswdw_Hp^_HH@a5VRkZ%55@t8_4e7SMt$2*sSySNSj#pTa^(#?36IqF zY~Bk$@wRZKO;t(B+Al%I0 zM?kk`pj+QRMrehd80>#&W)@%<_t-V2b@`))`sml0O{{r>hV%9*NvLo4;}xecEvmD= zd^i~2PlRdP4(e-v2oQP^lk62iU->Uo`3p_|fuDPc)%%t|*0B3ARL_#1IuL<422STE%IXPYzzdYLceIc6^YzRFOq7;0qZf1=o5{t-lT`N2sC!z7-m zbUjv%G+@=v#Yu@>c4z2oT6e`JyFHIORIFxO)*g|5OYk9?3tp5#-bGl(`F9o{)*Z2b zgoYRcpR8}-T@90<^{mUW7={n)rWou$^7@irZj>HrcTw!M&_=DN^L1&^I2(Ye-76|6 zPH8MfNs5cehbPe&{cGRtU1ad4+dGS2(W1o|7Q*CdQ;N-+*8{>>4m@Y@*=uAXoCmBJo$_M?IxByJ`o4W^+pM349nD~K)uXf=Wu`9IgMO!Mc$>r-P? z>x6Y0VeM$i=fmqYqg9c;YBs~*^=QF{kWTsY;eDE$Atqvfu$m3JKOozx+xH4ua!WOC z`UkS6#)z`am?svegv8T{=fX?We+k7RpY|u$j21?YH5d5wKX3u2(Fwa5e-$~=4-sn6 zFJ2IQ{Be4gG*werDa_mwU4|~VM1-{=q!8=>g(OR+=0PR=nOfB6v(V1Z_<@F~tiDnqvJP}kxV^lXOL&1>bkECDWLf%6g z3i>5~T#TyWCOTAS4B8v;M~2+cK!4oPiR-%`9D+C6^=ESI#sLwLVZnvKFaPP+_k?Oh z{Ev7*6(Z{YBW|17DEtJblo~I2F6>1yu=yEqtv}-ge4!9$5MbP*+26@#6x`MUcS1R^ z2h%Po1aQ{i0$!@wi)}YK(9T33z4ST2jO%busrq^t(l@=V{Qn3oat}TKsinV;&*E;d zjL+gMTw1EW5{9*V<6Hmr5=o(S7CImf=p4xi;0a%|eDaG?ayMoP|xIb zz^wANn8iPc)I22or*m#8{_-@L900p!{qXaK(WJ;}%>gNB(Fxu2RN4)8d0F!7s^36k z9uvp%42yy%d0I1y^2zG&*OP8uT=!%55CDj`FH@Ml-wti0TnSclDN=RSygveA=vy?H zZ|;MItI+aVbR&`TG1srVN|tVoO`6S9Fp(#!K@=dkdT>H{A-15BLTJqot1&jm_B)2w zuslb0M1^rN{?w2v^Xvz66B=Ag*i^_~8*>xRDse~7S`o(J(t{zBqqTSYep+4HjA*ld z5Bj)I1FbaTJGng5$Xf!DRd3s+!;-WXQ z&jPinh;s|%Wex+n8Thi$e~csl)B==9N4etFC7-{T4uqsIiDAu7TXEHW;dfwkiI)C$ z)B>9Pg-S7hgl>bjEyz6tx5RuAJ(ifhes)<~Fu_~^qNQTu`QcX67X^AYpNN`&HXn;h ze73|}mawGIx9Y8JFd!s9sE=+8tf$MjS(<6Iw$Kt^7MxL~jBSjr56q_v&gY4<>>?3C zrqUFjb`+l${EekpADtVBNtbW_Un=OYS`@=c(hce5l2SEsT0?ZF%~u}@z@+SK;~yHWV`0g)kZvG2L} zDK_nRX_K+VB6*e7Ysl#%;>4#xRBowstf<&D(P5dqMGs7^D8my4Yrt`GRmgwXZlQwX zpKmP|@vE$&ws>S55yNwI*DNhPY{{B>dw7BsRX;u?a1G-~M|I!gDCC3|PYElVlajKc ze@G31lM(*;bwPyIw`S~@JI`*Zf#Y1V6+-yz&L68jNzzKKK5Ej+7DHV01zt-4dqvLt z&YuTEI`lgn6rvnQeI@!ki>stLsOuVmP3e}(%_R3IaxFHcqJn+?Tk+xAC0xb2q5O4I z?+mj}p%=aKsslm3?D-p#H<^k9;nd>0_95aDHnKPAm$xoGKkpAPL8AKRa6#M$GO=Xj z$U&OyJUnB3aS9P(K-!iQILF04UdeY~k6YrCD55$tH4kbzuG=!@QiLiFlx=e|k(Uot zW628oXm7or6ZH>9T{=%Vh)jK>`t^cR7^K#pc&_yTlh>Y>fQ4&BOTb1?%Sbx%0k!n5 zS71bX9V4@Jg~o&0aY%SP$c*d&6_$*V5e7EnhLuoE1Z%8LKa-;TPxv2e{ACAF8VbX3 zy5+K#`fJh`t|BMhkt~WzX6IWAk}I+IdYChv;?E-6)Cyyrl9+W>pZZVBgwHz3wpau~ zD!IvLWP*)R@0Qel8G=6NB%h%PO6ci7{hWeUi^Nc~hOo3`@BaO%Gf6#n_n?~>b}pOv zbaqKue2Suo<%Jbm^67ALK}%LHMLu|Cc}x&q&}UD6HS*&tEHAolY>?g^43A3sv`x7+0J9jr54+G zZI0vS<5Yqe;WHX~g{RUolY`Dgz*CtRIizwz{g$#8TcG;LauMH4Bf;NyR#h2B32J3wlPe*b_M6QMG;4$A4t|M;o+9l-bqSw zuz!9=9)-3PKpCkM=aFQ%vxO2;?28Mzb$uja^g~41goZ6yOi#u@>iPvm`>x9mii|KL zlr0pX)3b4kXovmLbEa{YNDtPWU4JquXv#dUF-P`5D$m$F3nmg;4zmX%@KTtBS0SVs z=L_6q=h(;Y-@$kG74kikRqeRzy}S%2=%pntf3e7LPlQ^EJ=R|E`Os{ zNA`j9LGgj{L0a!d?v(0#NF0%W2@SLg4J-=@v{J#%JZBv!DKc6xgK9_a%og!hiE_Yg zid1}zY@_uOKy$8?R6D491-k)W^#Lg0cNKO646}JxGJV6&=3W@f>*0+YF~dhZ@@sBW zXKs^c;NMtYBFLS&@Osn!cIMq2^_%#bmmlcBfmmd)<0cjxUCs51Cb&ff;e|;F`7GLqLpds4y&(swCz-b{z2{Zk%)BeI!?uQ zg`I(qR4?LCh$=k-X>kf{E?LBj?F(?ia~hKr4>n3bnla^5$J*|@#bt-(cK z;Yuu>3CBNOKjc4D{=Voz1lRaVjblDRrl}a#m)nT#j6G7e7i3NMkbXmF-n$?^M|a|u z_9*Rjvq{R)1PZS}Y`v|1HMgtJx?X`vv=-PJGxT0TdXQdvxEnMcXO1Hg!~xYlftOYpAv%RTYsMWIrU7sU9spshhy{a^#32}u#Zd3 z%PHy8QsCs(j?*)kfS+$LDy!y_CDDpBnY^=~G|KirQG4L^^0-VK4(c&y_^&L7gCK#F zX9vgezOIA)e?`w}@D6eBdX&!F2%isD)6C3vcYWM<4twT9w4u&F2r#+ksS`aXmr_bs zQuo_Q#}K9FIHiJpY~4Mg?T!T(e(9tNK}$uV!M_yvaIEMUPg7jBgMS6kRo@>xkZ!0_ zVIOK3xmQ2%z9imUh^^v?&SU*gYzF&-bH4a|3n4~|&12mR^WXjUfzgIcdPQ9L`cq81 zFgXMIF!IVX$axIGD{i72KSWyBOZg-5=lUuO_QeHO{2>WENL*@g-`jTC!4FH|>2HeS zG{+3>Q8>DvS*3jd*L`sh&5XO@skCE{PGkL_*gP027{*01K5v2c#U|&s@MFU_7#CHq zL!Y-M$8!%A)y<8;Ry9We8~7n2uy#SAp_uzY6X8rj!SXU@LnFB9e}_f6?D9jv+58Fp zfw2n~7Ek~GFlL)6;a}Q(05>9dX~A|@Km+GDJ(734Fll#ih<7eDkL~37WnW~D_hvV8 zbp>8*jwy??@^vL%2#-}}-vnPU8!~}zsgIt|9jP84z|d#Jjy_i1QC(5pa@|;78w}km zv^SA>zwJ)Sh-z@v5O?tOwF$#-x;X)ZHFr=0N8-u)YocD+i2Lrd#>uWF+!D|0pPwtd z*HKbTmfs_HRNKSQt|B3G^z>99R@)b8i`;h!qe zvR(X2;4#>fRd2yiJ$4vWRd1O#EkIN~|55EoQ@;9+rm1HnqIw3F2EhJLPyyYrPv~K! zI1`^V4xr~H82`Ys+;N)F_$byn(VVV^*xhd81Hhtaoznq!w_WOJ;dlSYJEH*V4V1rk zhatsrpqs$=?4H)_o~V~UxqqYiLvzQX70yq4y=#a(6r#9Uf4}0|1InmgJ86ZPmq}Wc ztjmFBXYKm+`f1N}SPmb`?}cow&->`t~^?(lt<1Tt$zn z1~e*tmy!HfIf^TOh{uRg?Th{7G7jD3*OD!II^SbTcRJUjN_RTj!%lZP)AO|fpt+bE zNT-=$nim@yD|Jl!gSAmD>TJ%y^KLN{apj4w@t!F4GUq+1(Pt#(1a1e5$Qk#YN8A zo%upA;e6f}$89Kh(@OwrJJE-Qye$vb(_Yk*=~^_NaeJ)JJgpoTwyU7BIA!xmW5WHusn4_i zhVO7S65}4vrM-8BtCu@ykq=87YT)O4$Ap2&L&fb*ULi)jw$jr}lx}lQouw^Y|LH<0 zmF3Bg%00o7&GPTjsL>v9VdAC_=tZ;mc+FgRe|L!0jDA^0%B^5joO4wP=DK0zMe51< zV)k(t#Xnsjn&q7%!eiwQqgi%Uez1}jtNB?101nKP-OAEqZiG2C@GU!Htm(f&p}8xY ze}1gI?HH6gSp&DHKB4CHW8mG!KzEbFG>6e!{2sv(TS7$3zLeI8&0y-=NoIpFP}7ARnMb%hSfGz zo0~zMvG~o;;4uDY%)VQhA(^p!mWEXudD)VXaR>3}F#vS$7;eicVcZVyHg|4RaGT#r zM7QX#2>h7R(Gd({OJQRu@Wy3ZQA_%hiEyhz?hS8&a8}mMX1%A$8264zYL9vwhivT2 ze?vOM`RG}1a_+?410Y7M?70{W&j&MZ%@33NWq|#@JN8>07jJyHSw z1gmUU*bK_bPt*J=8GVN=mf9lYS6j%p1YV5JDu?usSU)M45pe^ITHJ2GWb%ekqHPZc zxLtqA)ShfQX>kEeRvs({*w?f@)NqHQo5lYdm>26A|K|S#A<1k)VQU-Y3q2cA9P)Dk zeDW$VN-h8g1zM<^k&z%ADlY^oulwJ@(kET_{*+wqsH0RJRicmA?EfNbwnn2-n7V=0 z1#atF+tjUwD>X$wt-Q$5k{0huIVR5qCJe?XkAn6U{`)(pF;8MP24a_zweD_l%AH0 z_+=ol*jdJV+MLH5ZrW?k4iV7WjzK+cV%y*nD&B{@X-0@Bc#FB?LUDHU3F7TTZ5 zpreDH<*fHB7hF;CkVRYtt}AKLnNP&Ao-l15ot8i|Mn%_qyo2gG=`ly-i#koEGlb)4qy40zBC2r9K1#UpB9CqT5 z>mLRZl#paGMd1CvF-&5HumP~mB;lPoK#clhhA4M}l2kXXjGQL8KA4Rz!L`eE@2U;IH?xY+@oBHS=25e+ zr1>iLYy6ZMFUgPcELH_vv1`oGPOZ}mFVxL1lTZZr_pNAL>1`!ZqixBPT&Au}#A6rU z18bvVUV|r8h-pI7;|~$9%p<~4K2hrQ*hD97L{VjJ4?)CnT#G^}zA_UX%PfS!JZ3}9 z$2YBVOzu&+-oD!kZ5$VgMlN>i2CGS~g6oJJpyGAJg)5@wiF04b4gdUBXA{FQ5&d%? zwtLgq&wDGv2OVa@^JuQk^C*9^)T?vDMjkdP?{%iO-khDa4_OXoLPf4@KODt+4RmU% zc(-XlVq2Dgytc_yg9}5Kj+YT@YAI?7cNm+k2_B6M*P^c%d}pVTe|B{Wqxw6B+oX8b zA4*E2n$XkQ|ByWJ1y`=`*}uDR;M^wz4(rW(HH{Wwqg@U6lT9SCpdRS{nr$|GzQSYT zX_I24YDC=*)tXT%Idioq}bTzTC^J*K8|B9=^2Xr+fbeL^9Cbsc;HRpG5 zQ@?pzGL_{u-tUJs<@*NR;fJs6*Ln5zM*6sFfb6ToI&UyYy;^->E7U4S#G0fFOVFCc z7zEb=wWAR?G^Uz5&Nu75!-PS@JiH|{aJCP{_)&S9BmI&0k#Z_iIF0F@XGjW7O;Ft4 zYZksTmgiMkAb}k2AwHU;w15fz(@_y{~s%fnInUDMx>bmuV`&yx_A&{=z zW_XDaG-H~~F}oIXczSMbJc)gT5o^uM_Qzotb%F-R-g&DEzM7lN?)SM9*VNL0A07lnKMrJWqB; zZ#MQ7G84^|&J3FfkEa;5^Pj30f%}^H+ExKpHm3|duZE0V2yrXXK=`zkP3<%;c*YqH z+_f~8F4Ag(awr-Np9JwqK@a2a;(ft|4UlQ(XmFtyV?B+`;f}qf5z(@^W#4+E>f;>hNB#d13LhRAo(E0OhUE!?x^}PDKI0c&Tu_PON zI6%ZsIpLI3uc(}9LE9&@DWrPe$6wqquavJBqVbP*Ul2h4jbNn#zUKU{;Z4jb*!%#L zXbRpNvcPwWA^Kq}(Z7f#grkMwB!sK`x$|>gqKGBH3*6h#z7? zOr*#SGY4yp0?T~jYTzN4Tauz&PG@@R*j#&TYw9EQG48BhQ70iSTo_nOD#VMB@M+vm z@r1ImQ>4S+gTlM4>(8lK!*PtqpdL|pq=6dKL?zoE03(wn`Z_%ouoD=C-bmE_YS`Em z9@-?$Z1KJ5{_yb0*7ghiTTDAE!A9h>-Y56Lt@8J>Fl&92vrce#V2-neALYdd;>TRE zG6WI;zB4&+weL>Iam<#&pW3${d0&RYm;cV? z(-7=KhH%}dM~|PCxywhlM?>s>9$%)=&uJ}l3B>e*2lRwis&e)grY@}rUVu4U3sdJ- z<{&mF)D?B%7jktGgqZN~M~&c!$Ix-v^4U)`bow7`aypg_%@U95g>8N=&%~-G-bO8t zaMx8TMKIq4 zW7`KP7Yb-?6W&2S)c?77{r1nfW)FVWd^aSz!(>c2lg+C{VCjN+)fKLIIbmKNwWxxM zg;%ITuu``8P4bo28=v8ZhPiRVcthblW0;rfg5-KX zi#|>$_&gjCG5x4dCe>{Ka6^7V8c&embjq1F{ZuS6u=}udkjP#2ER>mZbn3mIl~L%Ufm0g(ZM&kCl=#neM0Ev_bG|D0EnfNz;o<^ zECXcXow;-KjAe0Lv6OZ7G9ADt!LJ_k7Kv1+xu zk0DETER~&r>$|{V-S+5nhW&D;dB9;6)pRkX>!s}#Jpb^rv~$(cS4Eh>@Pp`Rfh$gL z|Ma*leXtvwOG$6%nWwXJX)lR`$A^mLC3@pSR(qw-N$9QiAc?QW%!A1A&XGoR3*~a% zmy8Zi;Gg?*;_fF9+L6vv@DuHbir9&_>fp9kn%Hf|c&FIan%2D!?s|uF{zjj)H`<>E z!Z8fUTIPL*z2^Le12;Nb$L_D$+Z4*;#tVLf2JiXzrB{fr=viZD;LqE6S9e=vkJp!G z-p=4Kk6bX1*cnZ?-ZcYUQ77u^Raw_?6_o2U%w_2F-o|_11-0(i2?l@X2e#^6wXVp$ z1>pI!nEU7n_6y-|fX^G)zSHycwmJAFVkgqB;q1n}bFQ(>uG#tVrE%AFCDyJd!$)0D zjZYR>e%j2p`pRZjKn=0Nh(J%o!+fwc04Z5leu1#Ob-M9 z4*-Wic)#l2qMNfF@2}MFth~t9%XGO%D`J1~%x4sHo*lj*c)*tclVAHweuYnedC&RP zy&TzFa!*${wr+3vfGsAsKwDq5F4^M-{exxCG;=3U3%ctZI7!xY|@M3LA$i5R+JdcO(H*GB!vWgNWdo}yXn+d$_UTL z_}*t{ZvIm6_DDz-;vOHv4)9>}2^c(O$t){pIuGcnjXY67OG$_pimv*W%%8 z@!qv~>`LP?>gD=wv3PAKUqi3N%U0rHEAgt@%Ej`lGqbxnb(xa>I0zInwK1htH^z#h*SqA+a zgMNlVKfj=#U1)K=!nv#ip174pj+k~5=mt&({lNe*5S#%9p|4w28d}K~=G39>wPY18G#tV%`CS&GoP%LAFwM33x_*y+HvzAD)3yrTOQtZO_dhxwpe6JVZ zt7mB%84EPRhP6b9UHCNp7XP&{qRt4%*P7Y!-DXaFms!Yopm+QYvy8eAz-G-MK{=mW?Soi}Ae_#>+oc_QhqfFz!Vl0qO^v&kK3G;GU&P}99BMMaN z_@~Yzl8jf^F~WUYy#pKHQ~$|$V3*phE>=ydSzWIF%>QfE|KtBm^%wrnQepnjR)1v# zaGm;_iV>&&Pwi7T8OlggHyfuI*=n9q1pDqZdKvxHT}FT74E2z4jxkz2YK%3`SC1Lv zj0x%+#zf;1wcNPOn5LdEs*S7FDr2^Bi+b9aYs^*88uN@r>N(>+<6-rR@tE*JCv3Z_(p8B(Sp*cYX&8y5As@1#>CVpbhGv}$lnzx$^RK#3p zE>!<(E;bjdPt8ZoW$JI{H_dOVz2>*fZ>cu(Npp?*KXa|Q);Ps{-`r{RF#pSyZRENN zT-C-D*9_MJW2NgZ*ImX-uEnnJ7%#i(T+bT6a=qgEneo2M<9f&Vwd+@|ca8r{OG`^P zcBN&eWf}go{%M1Z5C1>HlM1W=004N}O_4E7Q&AL#|MPm@YeiZJX^4XwLX;phPc%{x z6${d$K(Rs8gvq8M#Q1~+ad2^Vb})|4E-JGF8dHri4#vbtba6HgZcg~$!=;+0|2em( z_dEYN7XqLSkMIMj#=Z3f`IYtMTNq918>^_G6G3%$ss{(JEKE{?ogJijLl9an{3y>Z z4;Vu9BAi$%_aH7`rxxeuczb+tVV1vKyR^u>#RyuAl#l9TfT&Twvy8sv=1Ls})03uS z$yy^pX>IlHZMuW+?q+a2F%Nqhnx+sThi)83A7T{!|A%}m`M7Nik*7Xx?#95?y7{O z4K}Io@Phi<^Pf?-JS~Tm#H6(ujUM!PE6cUAL7zpgv&8aPv)a#dll}9YdC~Coc*K~la8gB=f(KPk4M$~x?sdK8-ig|07t2WDTbH2M{Kc{w> z>zZa+i?!W|`;E2FD4Bm0Jz>=$SG8F>+}W~%&(b(bXY>Ef6=`6voyQ@2_ZWE{)}oH+ zsGim_J)>v!oQ~^xE$M_#>II$BvQ~6jFS@R>#l1tC+DV_;#5VA{jL%D}?Z1*91mdLT680|rAzCI$v3CJtscc2*`P zmIVw<^#KeF(F{-!kmj1guz-R0Hw)9d|7;8=n71+f0t$7?co0JLgNdKL$(*_8X70_+ zFPT383D2IcAhW{5)9lFI%km?D2ANGu3^G@|u$nB?hx$__MbS_iO;ahEQfUpXqjbuo z9ki2j=m6zY5tUE{-KM*w(*t@$PpDaR5dk7t^b_G?pokWu#3V6A#ER)6UL=WRF<&eZ zsbZN}Db|YhB3)#NOpzsaiyVY+!S|(T|AULrFN2!)KTgog-H?8AUQ!! zk{8I!0k-4SS<;Gz9EZ4 zQu8+EZLz_&!Io*;Wy`h|H9c&4-1MaBw_k*FoU`89;Jp2Z%>2~Ul+&=Ef+&6T0R zo7^T-ZpRC`5>X+ph->18_*U3VIk@H8OI9hwEeAPKo-Z$zx5<0tT=}4URIZk5<(nS9 z9zn_oQ*NRXtIROvvXxxr&?KQ(Vl2oX>fD zh!64s-pkpX#oKusZ|3E^gctC8oXm+lhi7v<$8ro$;ITZMhw%W8^U; z5L;N~_Uy|(?9E>6$!)k5w=|r_6XUV*lX2g$8$TG|8x6)+##y7rs5T0X0^_)G)OFAG zqw71@EmxJR!d2!vLq%SUZ@x7$Ms`+o}R1k)pzMz^?CYSJzkG$Y-p@&tZmG` z_ux*(oz3wd#-{}d>niI~>mutyYl6SkKfqu0SN#0EZh1}fn(8&Vb&qF%@&DsLj25EJ z(-+|%h6M3^CjHA9&vwf2KnpW9TcI`D;1zh93D6ep;0+)6!Vmsvj}GXFPIwia(Z$SK z1u6o}l&~NWRs^9Nx+54p&=bAT8zJa}zUYTg^hX%N5rIeyz(6yV2O|ov;dKnbP`rU* zh{kY?z(|b3n|KSO@ixX_EXH9xCSW3B@D3(nGNxcEVlfSIn2s5kiFnMyY$RX~<|5I& z|9Wh|Mr_6o?8ZKPi9Gwjv8V%^hE0FLIHCM|6@Zv6M=wjLNZ!s?78){0oC@=gj{a|3d#*0005%0yYAi z0<;3=04@L~0G0rk044x806qYe0G9xt0H6S|07(Ex06PF+06+kd0Gt4g0EPfD0E+;E z0E7UK08;=>05kwO004N}T~p0&(?Afm^V^@abrNVCtq)_i^g!11zy%~CEL)^XBBUq~ zX}8KDX_^ClfJm*#nQEVATrNFw;K~J|96&q*kAPs-aVtR9?(8=|-#4=>qb1O)_wms{ zVsD|);xAk*wPahRzNLb%XxAUR0onq-VWkydPV|TJC0BlcdGXc-3-KF*jJp4zmB6`DiPtX`n9G9CTOnsVP{O7!#mlo}os4SIq$C zQ2TEHZ495DPyU|7l-30eq2HTp>z#33Mi|KF>?1|)i4Rt2hf!qrZyal8rMpQUNwW_n zKc((@#K_n@qMHwg^4bC`o<-L-*kll9*qnQ}TK5H#m+pnO0QW^=<>EJ35TTPR?K8&`_KrkRpJAOr{j+kgo(dusy@;TJZL z5Q76YDEa>+q(PFS^T*+j0PX$n`_1eXS*FO5p4*+B+46pGZ{It_Ob!ylS-2kIiG|pS zi+IT;qzkXgn$YIC^U zxnPHA4lBI2nCwoE7haFn8e&?^w+p_slSU~Y6c5tJ`}e*3-F{km?|a|-o_pWT_0Dd) z^lbm^3)D;x^nXQ7{coP7za$)~EWAkmgL{Tpi9imKt`#8b@lN72mAg&=j;dl+rKdHs ze;)tlyk=@EYl3$k0M@+Tc})V~1S(2h&T8*;I-1!F$GpW2$3%1TqNI6+4glC{w(0@D zCBrMNU@Ktdvz6wqW^-4`o>(=Vus3Fk_^Qbro@r9roaw)XEG&>M^u6?9?iry#oa8w| z1PgI`0G$LMvfKwqlqBg@q#FU4yK*4hXf(Q33mn^=E;#NH8nL>|bDS89=YsIkPGY9= zoIe8s+~Xj1d+=QHBwP+ z6*VGgVfl<|6Ev%Q=BZVCfAl$aF;G!m6*VAea^Q^W5;P|~MT9vnV)en#u}2F&s$pTy z9=5?jK$vp`oNyoub8guMZxGm{$R7Rpi0=uq_rRw@>{IZa(ZTn`2Hz9M_sk^*?@Z!( zekR267OTzfaJt-r=$8Y*P&g8e#S_WO%luPkBAS-~B~2a)DLGnek2Ts^_-k0%pPXfX z**5&Grf|t~Tk7bmC$~-BJh^r9_#LUs?^v^K?M-VhT6_Ga)J=c4>AFo{fq(Gyckpl1 zb-@41!XI!h?uTTE)JU6rfpoJ#MOA5Nb^E+(t#`9^M|o~0o41#{^(-FNc{mh-ysD?6 zMd3}=dRL6%713)i&jqty8*uA*Rdt?LNxfGVNXS&~nFS((K$Qh8Ps?4ar&6!iwVY?Z zD@5U_uI2=73?wZjkOaIfoH{M`{OluI2N*kF7A4iv(fniZjA9q8i&Bp`W0f{Yof;K2 ze;Jv(-E1}L!9Z}Vpo}$JfGRmbWxpkxDJTUwn4m!q&C1!a3h(p7n>^H4Z;dqzN-dal z4>g;Ablc(agI6{KF-N*u*}IR@hjxum?l1fA8ilt!T&f>>O=2i@t>Xv2$=eSe<9F=f zHs+Iw=mGn4V*1ebA>*x(LeWgVKlahW$60{V&QuJ4fpq1cNR>$lxlO|P(P|fYBe3fV(cjc=nU#-`F z=XMk!v+5C4=PA`KsIF6RJm>HrS9|f1p93!T4tO*g1_i^(osKGrnh6w*R#Mw^q|2EzoR$5lU$Z^|7XsB|@VvWI6U&R98=g1P60)=Pk(y#>Q$@gkDto8y@6!F*qz%WY!L%l# zxQ!^*a>6`tsXBtJX<|&RnyS4K{Rr5%28ea&uN(ri6#-#h8;9o{*bJ5Hs3W3U?x;0s z&YCWu^-vw6mMj6z;Ig-)21HE=BfbhzIFanAP4Nk0a)irOW?9jj2V027jAi6)ovZh3JHBap_WE{GUK>hYG;&?lRJmp6(c6!` z;a!K;tdHM*Womk6JQoUQpSodY>)IVBcCG7ditoH;!#m^}Cg4SP4Ug zX12gHkNV7~fIafk?368jFku_6aIY@rbESVI_}!N;+)4Lye@0}WRM!IE-Lo>bi#m-yi)g0xIDs{ouwiEiws`F7C5`x9KyTH!BuB+Ux2mn_b>Jp%BAw>&&D zT5E=o`2vy_8Db_y0ugLAt5j)E(m9 z;JDp!te$oyy|WINNj8V-A+yXo9kZ!Ox_;D2?Z<+4Pck=cbMpa9a6D)U@^0I7K1m-} ztO-sqrNydbajyY$zuO-O_;sE{@ZT*9jOtIBG-)44~E#pFFshi$b|)oC*U zzDI(7A3TyBKpWJiya@OH%c$SAk4$EJbm=(r;k3r<1hbm$MetQ?-myhkbfaP0z6H+ZVrCZ z=0x9ws-CLKo$fiA1?zH7_)@}|;Y+>jOPM?lefF};;PX}RBj?GVf;?7N zdXdYHnTReqlPH;F$uq1nhfwzeb(k^>KLa^@24LE(`^+j277F-Kr40lLEfA-BXlBDh zyYYmd;V+%e90u}WfAnUm-xsQz$}_Z z2|RN%s$l`uu%E#!O7p5HXg*+YyEL!K@azLdpEJAMCgza~61<`|J7HQ=YEEFU;g0b;}QMo4Np?bJMK6>K7RZT{fYkY>|@-1So4*z@Mi%YAMzKA6DXKq zsm?64=5(P2?l}x40HB#qYaZ8p*JDOz^7w$S%pN>6BVQqu9y6#s7s^{>3bMO;SQPNkAG+29#yt*#Xgk8tJHJagLKhVblk*q$N_Q zwIX1yRnk#ya7{+19F0#4K}LgOMLV-(hb-1~z10p{(+U3b+Zy@&hL|mvXut9DtM1x+ z^v(iVNG0WLvEPwSzJK+NQ>~ddDA~lCy@!u)zN|5`S60lQX8aWe+FM~=)8wy6cVZBe zStoEUR&+N@%o~Dpi4vYmWbNgi?3yUK;mJ<6K)eukc|G9tFqx<7>Z+=o?xl5WoEB6w z8f~Iu0%XdpAEgCmliI#{HG-~H#Wkv%Y4yBUAM#83^+XSYML8sRw$fULS%vijUXpX%mJ!! z(N-euR5o7P9to_m$K&?3awOw1+cUAui0Dj)TK63&Z=Nl_MMyW5*n@Y?9IFLyPn9xv z|G_1zJi9#c(VQ<*9Uh;|rW4~Ad2_S1>+&Yv7RjwC9=S3;QY09+`QSl@xXnjG7c0-ba2xdFTb0 zZ1iI8oCJIlvy&vUMu}-Fv(6f3L304WX^@H`Bs|#bIjfp!k}RS za1aKW36ngzgLFfPg*afrgrefH&-Z-UkO|i9VxL^X zf8gi)Zr-=~;;rip+w&qP0j&dMw_)cg5?5lxoeMZ9E-P47-KRC1517EsxDuE^3n44I znQu+B0D!Dn1QwtmD^henVF5rR4|q0)Fal>Xf@R9|vu@|=ZPRADwJ`G5-KqXB5)r3^ z{^!SC8}2%J;M=RCh1))U;yRxnBnfN->Mt2+5h58HEK@c$tC&IeNtd+8&^h6*UOQr2d z3XG?ii%GO}3=VzZ_o|9GXY%q$Ds@=WToywewa1nz?m=XXF#{u127-nqnnh=)uY1k4 z*WWQwo1T69$r~U3VC`_Nez5Kx&M8AfO1}K(Yxn!O)HQpK9NyR3;N_(KYp*$a?1~M$ zcW;>4wTqJW#@X@C#!bMdNIxgwCI#^p@Tn6q69CKvn1d7$L0Wl4QW=nx$T`7z>m^t) zM%599r?hK+&XdMC!Z*<87~rbKx@HB1UBP%4EY=fFKcC1AF&7|*L1wh0mPH6SI*d=5 zE(SHbsC1d6PIK+-Qrx6tA#>l!H%+%Lp1J?Tm9=ozDG$X1>6FBAQycf*`u^7FNYFL9 zca(nR`27cVeCWA-8+R)4Vrse)=-j$@`l>tD>{5Iqhi<$C*kWNp_r>V^wk~HvKi{gWE9P8**41o=n$kFvkq*ksZYr;$ z-|4@e-t*kVezhTh> zHTDZ5bj%FDa1Z>#cgzRh_x?j)+fA4b@-MtdHSh}y;A?)AbgSr*lyz?tBS9?%bWZU| z=Tsgnc0jBmc>~O*^!yHzMk1uc$0?VFz)vBYggzGsA?ndgc%{t^|a2gpamc(n9${8Lcoxtmu4X;N{a%o ztX`BUZ6jcB0xg!Wqk6?BOr=`eGlkeoOHaDQXd)x5#aEy}vdKo12~({NZ*O)~AH6NE*nUrcAkbxGYA91s$=|90*&x0f=2xE;7X9hDI!L-EeZ*{GktaWv#8jn2ILd<U3hpe*TWn(`L+?=xEtu~cU|5{y$+5J209Q>`eVcf zB#AdPzkOcyvE1|^BR%!%A8;(*u~s~)>6BTEh0l1@z^SL6$^Njdr_yY2#ePalIM1lk zslf-Fs!5o$n5@3CSxpFYzJ#QwkNtrd9Ke}4p6S9nQg2SZIcxEVQinWYve>0SLeCJ> z8J7uj$`WYrSUhn~@|c1EXUC>#yA`DkUxEgizg4AKAP0sWe1p%%N--CI@YZ|3?1&Zn zUz&(Hn@<;QW~(se`N(!&;e1IuC3NT6k0eB@C>B2b$m?^0kD3*#P@XXRmj)a@05}Z7 zQJK7rbc3knqagi3BXDBb6Rl`B4s4G3UM3xM05@mQA`W8`MGJu=o~d_DAvED8n;m@h zx*F1zf)8|nf;zwrI$#7&C?Q?PgV+l!*^-XxY@HFAJyeU5>c)c1m>z2t#?mbEW_AyR zyx`Ye^D-R+{?pkq-3o_Wbj#hZ|GjOOch-IIP)50T>!wC+!`fAA(qX`aLjSMg_&?RfuFkJIf(uNj_;=h~@oWA@0ZL~8Z+ znepW1$DbKR-Gp@fN1$VXa|B`-YM$1NB9o|{1x&^(ybuSd4RPtfSy*6vFI@7e5^)#VX%;{#1cZ1 z3++_8;?V6BDBf;5fEUtn_*5W`hk*!2*HyOe46IuQmd!Ahg-~C$)zu7RSv6AEV(xi0 zCTK1|i_@+9aq*09yPOa+s>6CZU=b}qRK83zmN;c3g_pEUnVFh40fiZYxTxaxrEAJo z*>hPX<5Cn?rgB+*bG)4K2b?a&wS=nAmCFT>C-4uM@&6dl{GUqH8j?oixo_yW$^)*( z0apt8tBd)KeErv>CLJJ%n)I(lO<_4|GA6u`QQ$qlC6TS#|g5Itd%8S5&&TzfE@BU$#9KtwrrS_n7j7Pe+hhp$DyrkbL*tZ1T0`E^?Qc2!?p=y2R$g5k zS~nE;SWM1Hab3BQicZo>-go_*-n;8fbWiob)mt0GPv*xviR9Sy=E-=tzH{A7PKv%Q zFF{OglCn>YwhtMy!()A%>2GEQle!g5q=(Q7+R+Ni4aN{oe-KXfyb8gX#=E4!3qF=a zC@`8A%0Orb2uEQ#*$aY}1F{QsEea@%V$41hO~SQ6y_;iY#9Rtq`Rl0V&*1}He|l_i zEQ`njX}G?MrWrfv3S_z!rdItq-0DBw3ir>1TT9%4N6$SsIO=-_M=!p}IK#jNy$o>S zBO6!d{_KWGsLnb|`oWUDunI3*uh(a+*Sl=JnEHFkDh$X6(4GsO4ims(S$I3W2H@}` z9Ls(ietNO~AfF3`6D7?%Frnxe63s?f7>rqH@N<{L0e(QiQi~OINJhuE9NsM?hu=)U zxCqSD{u`oMPRGl_FSx%3c=HR%n7gi5%1q%ZHOQAvwN+G+F`qvb<`6EMAC=bWNo#-yd z4fhSl9P5u9tzR<6or~)q-Z^qC%v*9flOX$=(S6P*-&wbU*TdH~-f`mp8gxLrvWfYK zCrCFs$V^8U?FwUC8V1C#V363aA&nsoUV&xI(8Gy%nL~44W?_+PYhVHBmg)G&+Cn4e z6-?Z6h0o}ft3*B3^oY~^RYtQQ$n|Xi`zQ^OZUJfLYiLE(>T(X{nsvT#_C`Y^2H2qM zMow!Ib2^OjRu#B)ZCo_gv_h56mgDdvPZ6KD37pPHKb{!w%asC5FSRQi~fkOfytj0 zYGq8!^6+2u2NM){Ej!jWq$fyij`HpN9)2q|F(va?tuX)1slVaPoKJ53B%3ms!`$1I z%+39;f8X}4m1>6m^z0Y8)%{PN9Epa(iB`;}+VD+upW*{rg@Mohn(5%z>b@f?+$@kK zsnZDq6QGjj^rCEm$}OG-wwdoniir3~8t7Dv;9)VNJI@g#>ksddSz$u@DcvejvttC?c+bgwcptN z+_G1QiM#tB{-+fS?r)+&8tgy!QY@e!injSQt0{|Qr(VTE=UGoGh-hvk=0)4U9@_*> zz(s)9i8UcqAsT1J1}H28^A=o|=)sbZ$*h-zT0$!o5G*O5KLNH@NDVzsFM0g&{^Mqg zoLOD^SpUgS(Sx7=eE*Tp(`$yd9-1k0uO9fuCxJF0@SLt&W)*^l$COzf+ek5VlTb^r zlq+ZfKd8WPz3XR+z#l?I;9sr?{D$)k(MjO@Uvi6FHBX4&VEFBvJlLnq2VuLFv11e*XxG&6RNL z;`#%(7nTL7&C1R-2OXTWbMwVnnJUBM!DidBoq50X`iI{l1`Hoq2D(?sL!?_qjy3^O zBt%NsK0g;IOSZD=ZLna+ds>SL^D4m@oazp{6~l1X{G6;1;C5so=@5sKz>~gu&uyt=&j4Hy@Bw;q^={I{Ze~D45_e zzhng@4dr83Pc)|K%!X2DZT7y`+`2L6-`S{4gqy`wX?#^O(z#~SutYjid) zCYu|F58pie(cKr1SE9pNzgtW-wp52UuFlg$N{@-Wz&FQ$Z{p+%()A%e{0^*?=tdGE zVX%+g2xZC^*?3@Iz^XW+0>$9Bw-?0!y7oLV< zTw#1K!XF2E{ujWXSgZ)yjowzEB3h0v?-7|_maMAL)0!1PwKC_0Rav7}=8WUYta@Qg zhBwG8`jatH?_h?*;Q_;evX8y5Y6#7S9r!#D)y;-sLsQE=7?$Y66LC7;2!o+(u;+I? z{N9JqJTMD+f3HXHU-V+$e&5X}UrTR6gFqL43Uqmtt?R#Z{|ls9cfYJoumJV0Pwz!Q za)GojE|Hw>`Sr}XU+9T`VrQ*Gtmp;K$um2D@Hlf$qTqzYPMI}p^bC3E99gFUW(_*#3 zDR4&?PYxUsO*B-fUj!XNG(VP?O{{r{2Q*qO;G#@3FIZs)nU$@;KdDfGR!5_b_m~~) zEK0y+^^E_=P|TYdyZzq3azqikW-ikoO}rr9dZ{3wvE}`_{U7ZA33n)^=S>!V4nE>3 zz;BVR*84xZiDU-5c(aU$oS-P(o`JK7EQ&whG< zVL1!9Q~;NDC*aa{>Z$4JpG9;mJK#!MFk_EG1{}e(pgBEfp8Dc1e_CfBOtL;+@H*WQ z_@oQ$PUOr}tG@Y@lSYdoeA)}&n?M>xPtC;>QE(ieuKwf(<~S?=Jq;_wHZqvIV(!hk%Yv^1lqLSI}d4rPN@wLh^+hSnKb4LQy6r zV^yuCQ|hbL@BBYRDNsjHhfirDIO|!)^A_7MaJwkXNg`l!F2x?x_=s0W@M;$>EfaxM zM@@IS@Hu=j(jhZ;i%pbL+2N6NWeLaUIk_Td-9}6m7)q10p~rs)D#2W?%w~iB^o^!M z$p`lC@WqB`Z743C;0}1)!SZ~u5ZJmUeos1>sr1!GLb%OzNz{{=P&t*HAh-qR{NJ@MwxN;$D{ zL`tmfe|T*|ey12iH33WQ|0MOQ1BpCu0fhMD2fm=B-#5_64@ZY+D(ho*5}n2)fCm}v zjEs12ft_(N>)?_GVK4_SgjKfN^d?E`Y0Uyg(!vaj>Z@a~B(8t#ZGZn?xPB9;0ki5l zrE#bq$SJTYpdo3OaIV4H9Tsf3@w1hWwO9{Lb}StvRu&#ZaC{#P-FIlKq;LUu|Ap)S zxV@ng5*63kKMQ<;cBl7$N$$5F6RY*wH*pPjE!f&N%rSF2#L-SRgKA zZ5UWP#v%rmi4iC#9sly>r>=hU+y91sxj#ww^gpTd%fjpFiwjQx4uVAG0WAAG{;_UG zy@gRu%W3*z-?g>QdMxPz9p}DFoFqk5TNS$&?HGNy7`Ci>@1x$U$twFm0xM{WVpj4d zWABtdlg@IF`ATy9_Y+r135W+u3omjt`g1Z$Cdqq^9S)U7FJ&hwKncF=HSHt<$Fd1q zq3oEz!m_o~i}~y+=Hk`B({VjvnQ=!!!10gS6 z>+Gb46OM^?+8v9oe%*DA&3W0JlB4{#P3g3Y4?DtQIPBhZ@%zikP@e9xRUSByGx;2% z$2zv<_N}yUclWX_isSCJb4}I zdJ%V0gEhBsHt-aP#mItLu>Cg8(8z*b-)Sx6Vx3|><_-JMuMFwkE!eqg1WOwK>^ z?8%EdVnOdYqTdC6iIeMfe-pb5kv*_q0`uK^LXTkLYY+iQ(mZaqaAB?8*u+vtH#!7L zFH~j0y-UIhpN#t;)Q|{nBGJ4umHkpUe!XLa&kL$7b<`SS?m?&7~z+!AKuCIhe zHxiJ|jYM=J5kc|k3(TQt7W7UrSXD$|{i~K_y{;$y;!XG#Bc#KNv2>2 zdka)IEH4f#R^^VG!=5Y6?J{y2`a*+aOC7Kf#}ZHSg#wKvg#PA#SJ#aZrQjSjjq>^gtP0BJki{^ z!H(cDi(u`87C?+pE!ni+Xf3ILWx_NKuIG;X+Lu)0_DHPXf8)MtZu}$bj<>@fx?6H@ z94`LXEf2?rCL6J!@6QhS-&NYO{|2}JuETm<8ij|C0UdM5kBgb7EI4#PJS~WIc2w&m zh_=@Xt5ahQ%>v8P|Cad=|a~Ok^2`sJ#ixZGu>+xVcLMkBV`BB@%rrSO@ zYqX>4M%Ds2DH$n>iZHKM1T~F~zZShO#!?-01WyXu8q_}Uo{*px@I6iaO0(K4=zWlz zFsWm~{gieGZd_V3DN3J-C9=74t<5^?nxYE6Z3tUh)q)6IPPBFn_`iT1cv-B~Ytz_~ zhaXqhi(T2x`Y8noJ_a_o*&eGdWVUJAEOHr)>f(zhT_$O(7(6P3xo6@?XO)q?F zwlh(yZ@TfWy`6iU{6^Cef;@>_Q{ChPU#oL8dvH)d9kO|Du6 ze29I+Hv%6HlMfp4MOcq7LeVnD7f#eAtmV-GCq*Pt#xMvYdVLUB(6v|}#6tYC;$T5f zfy$s_WL9mEv7(Y>+9nwR?!AH|5Fyd7k9!AuP7rMa{)um^uHMn%DXoAe}zn} zaGW>zt4nMC!jFPp4w-skfq=oJ4elF)Vj3aDX92Dz{>OpPE~g7 zS1oXG^%d&O(Qz#OlCcAHtD1rH{5q9er*ZsRjVEjGQ6saeWA>;@W{;^R_`Co3)q^h~ zd-kgY4#p3t9Gv0dFHk<968tiNW#Pqz5H;zrSOFG_CSlWW3yT_1P1(&We#-<0SBzs5 z3cSJKh26jlCCnW%UWhYZP>bjC0TWf3l`DJh9Pzv1$w(&;F|Nq#T#;v7kuM=v6iKY3$!?Z;!c>X)vSeq`_av1qAXbCS>Y!FQAUd~ck`HIzdG(RN-h+kk z!SS_`=?N}SUP<@SD|ea`slcJYgIA2$Q{l|6n;#wMF@^^^40sT+KY39%3+Et#RV-ks zZeVUVTc;ZnY9{yMIsI!7L4bV2=4UK6$+Zcy8 zOgHdwx&v=$2#joLcte^sMx=53aGAA;loeR)MR0W%_sKb3pc1D=-2T{*G&#sp*D#CF1WjCL;$J`MqK;{1J=AITzo+$ri!lzpMoj%-cK%eqrWg?{O&|rl1S)j2~oejg2p0f+-0a^4G3k8sB6eY?lixP_NTl?V+ z{={OLDZ$E2iLg=ZQx>tF5LE%&=BVB_XBS_}a7=Lqmm^kLrZ@*!tY%h6w{E2d=J;(B zA;-DsiunRNH}`+Jh@<|YWr|bxQ;UETo>(D9)4A4y0ftF0Ni6PH1M6khm$*tQlB zQUVd`LWZ;S-}jd;jyv0@-|8QvkLW(IZy~~MfbUL%r}2Q%nFtPUH;LW_(bG3x6Wer+ zy|;*So3~_RAv9GhRh4J^B{XLWh!f!#GdVoV=(ZQ*DJUZV0_TQR3Ypxz2 zo|LVpPz$&WJO{(_J+Hp_#)**YVZ=4PH|byZ>E^rE^? z>_K#R9ZV5p5TIHcdTVB$`Nbg#T_qec0r=AFz+!fZZJ>1HZX33NQt}uMq!hv^KxV!& zctJ#q%7e~K+<9S=SR11e1GF20qT{=$*$uCSk_=Y3L_I)+)9=pnrGx`*)HNB!*n=*(E0v2&%?{qhUAqajdPI;)~jvMFj&l};k1 z2)>j*k`pu0$>rj*zgAFE*+4{)xBgSo%j-Q!3dA!XhxKI1ZTj9nR;%-%gvdr;DI2(8 zc(qJO62knPn84zk1W~9|)kLG$G=v+oXqI)FK4G$ZX}T? zxp(vEHu~B6z4zAp|9aSwY^_~Q*Rg&Y&{fw19Tf7Qo&)Y#bO~bhwxC1TT9_iCY)XSF z>YX)0oyF9d)0zpm%IJzjwQUkKr=hl;OjkPvBb+v65cVWc$%$LdRKKK2Y(Rh|sPEn+ zSWPu@BG^UWW}Sk|V(J3sNEFsS7<|@xNwR3O8P3BuY?el9A~C(&>84NQ;+FoY8)80x z?ggC#E&Z!duEtGCLENzOKj9>+FZ?$skqrGliIb1$^+h$<&}no|c`?Bf9<0dr%lWUe zWM-&>)fvqe$Mp77Q~&+Lx9H`YUO3`gyHkw{bKz*nSMI{&vO>+1R-4@! z2uGJn2<${Kw0LT(fcwt!Uy8@1=%7V~k_MxQNI{_9lOl`ibNaeK?> zh|n)7ikW&m{eSt^Y#dYJoHw%ex*z_{yQ(2+sa}S7$dm7oZi?;oN;Vq$kAfh?D?d2|;rt&OG(>M}BmgeK1y0ofXzei=T7~T0D7%%vs}!w6Re@A3YOe1+ABq zu_V?x<7VRmG$FcFUtl=I|L5RwSuM*H^V-bY_)D+3$~5jY2g-k)54i%_O*ft}9lG(7 zxX&I$obuEw^nXMT_doir$+!vd%8QBSt>34O{@1Df&{){ZaQidhF$Hj2BVRN8qrC1P z*ooOHuTjIQSG9(Y#Ao;Y-G}vRid|5LPH9r=4B!%8%vtP1zVe)vJ=*Y5 zm4rE;l!li{e8l&Z@q8CfE~{iEJ6-q?9@#ozxYTlo%s4D|$(KwIm94hQvU1jWPp>R! zRp|1HmVr;)MIBgP&SKRpZ?O;zABgPtc_V3R3i{mB+>{uIe5ILLUER|OWK#X_2jaqJ zZi5ubDrPAXyD58L#P7zI0A9N6K$zzhg=S`E?zt$2B^;g)-*kPHH?um{f`=Oc9FLG! zlWr6&e=n~a!#p+vkUSbYCf4Vav?^6}a9CsChyNp{q&DtiMLJW7W!D zDjQWR<4Etd%STyK2{l$|sh|x@USulVk;Pf{MuEZ3>2|AtA)AYal%P|($ii(At%1^4 z!Q^;vo+)f=CF{kI5SOHg+veGP+{?Jk!YA6#N&no5GRfs)+5S%+zj}K%7H`VlS~B~; zzMnHQK3jl?e*zrHun{n>8hv;X9KTS+cIAJM5C2 z4wJ>?a7wPQJL$?=E}HD{nV?c@hL3dGfY&1n7V-t|$Dn=UWKg5y+2|1C$*5Wd#fEs~ z=r8#H_*IDLvqA2sSw@e~gIz#+By}o`5Bjy$k!o*vi5}yp)nwfu$y{S(+{S(Y@yl1$ zSfkg_Uli)y28%ozBP_aBM=@n-(=S436m0ZH^%uo@*EY(kmE#6kc;L1mo`eb?=ZQEVdH`)QT4V^|*X2SrQajd!(X?y1I--dOS4v3%sFiSdnB zjfdZN<&|{zeXliLd@*g+V#)kgbN`xSfekbC$}5Xo_U`;*n7-SNbDCiBW$sb%89q$9 zHT21cbbIEp=&g)BtF7j7m(_FwCyS`r`kcS!!N!C-Mon0??Z%jvk7ZHw$Cw)q(F8hE zxU*K&7Yt5@7IWf$ViV3-R0HA@o^-BI(s!K?)c_R~L#nQ+QpK8qpK1COD-da73}tII z#W^a4>{vrNx2gi66tjqOHXsKqR=H7MO@r379N4@$ap#fR4L4kVtQm=UB1$+~NZPa3 zcf8I-hll=rI1hxdL2mh;x>3jK`~jqBm_?^^dHg*f4zL)yRD`VelRf6|9U6*M}K5-zV-I)elg75kt>+F=r`XtmSlTk zOv=H_M+5HW=tF4^UR${IL!&iMX!L{mlnHq0$ihyrlYheUc16NQH5t?2ASgFXrD_=* z8TmRinmjX{M~{A*9_fFCzKD;gzp@K&<9ysRAjdQ0DShG_w)=NoX55Ze)k<(&LZp#W z9=)+OOk34Kv(^QT2PXBgCKuIb6!kLt_V^4d>WSs_WSO=4y0yfE-^v5beZ;KvF@i|w{3fNg4&>Au6ALql>v2DsfnZYY%m>G5^=v68x2ogyZ7L+t(SI` zR64mc9?HxPw{Cd-$i=ly>l4a>oyttfR$z52fg7bC&DZP)0<^l~du z037IEz|E!%1q5vB>6!Hrb~unH1~z=o%6T1#-=Ns@IDJV)A6_?S;WOx9s%}xu0xgoD zcGMhd+8GxynW^37wh4g@OJVu231MmD2WRLN-pFGqOPv;M7qyc6Hm!X7+x_QX_tEcv z^rPS3cI|ZsYSGlDTBF%gYI4+B-+%IoFVW!_Ug&@81^REl_|&I<@u~jb?!PI1^%aLU zZaq3tyFPiXo_mf_JADhcos>wEe2`%JC(-DQ=mV>wBL#3;VyqCRj#f1jXd7FVwPY+G z;x)#k$qPD1pQGx~S$9Zakr+r>NT21|LJu6PMum=A72zw`0t;m`v4N`kB%k&<1HKX*rY!X?2CAo$^g$_O9zM3=l8Wrj1zrBY@S$xZlM!1m zMcZv5XtP-oQry#M-4XR>cu`1t>6K%_m?tX-CKACwx*{awz6a7l3K6Zt&5Jf$yB?0@ zck?E16meD~dHN;#4e+acBt}$wRrNKn0Svo}-E7yTv8A%Dpm_vkXk9w0iQ=EeFSgk( zjz<=c{@w3;TK=@?`&0Sp#UnO9@G_i_Ld>A?jX8V3bzQ=``-us0Z()sdy7KCp_{HR} zbC}fNrwhZLxG>YXaLPSUBewumualIh=EbYS5<( z;WDwqz6U?{^IJJ!pq8k4v43GkQfoNz>In<)aVGOj?j&ufjJ!2ABuY=3iOZg^F@c;E zwIupH>!hBEx^1x)o30jRZ;WjnLnBt#_rGv#|I1(p4ApnQ;1*9~G7k#rO2M3t`h3xE zykWEyO4zNGIt8oPE-4PHKpiQ`AFYNmf;S!ZJI|HXXvDdNsX5qd&T;&ybjcf zHeO;TNOI#`D>E}Y%;xwl%SSq8>17+%Uv}Apmt9ofRBvpmbGCJtUi!vMFI_(}F*#hG zn9%hUo2AL+VSQfAz+={JFg_E4Und*N%{Z*yHL-1kCJ$~SWI1fJ6-7m;s-Dwm>fO42 zvemn8HvZ7f>$`nDtkUga3GX^i$7TIRX_+pcwMoC*k3Dnri(fptV+S4D@ySo_`1r?J z+!v<;y_e09x|y)i)0!33q*Y||0iE!bscJ85jQ&d_Bp9KHx=5G+dw$lCr)385N*IS} zbUBeVx2v_re%b2PI(7Yi3BrzUG1Ss8NqY}e?$0|~GXH^I6Zm@mlTx+1Wy z2%BSvMMkw&)mK^@OhQy$RW0C{pR2KPhdw*08UA|uG>S6{KDIxhF#C1UcEI{8dP8Ce zuNdu3=*OGW=)QPGAFfmj;YKZMz?G}vs{+nT)8(7ZIdoLOS_E7W`-ph9qeZZ=5-Kd4 zt~F?L%Vx&(QHP7otOcVIwruKHq7+CvBB?;6<*rx)0ZY|Y%td|nRG>)dC7WjsG;+gJ zyN|6pMvsKE=`H2r4p$=O+CDXt3I+4^(N=!g%3H=uV{2Le^X+tjzG=`e?5y@ozouWf zJ%GhaZ+|Dmn^HEL{tOrY{kUB6NeSsHy~g8VHJ%#zGty0*uf{V(Ahdq@LJx$M6;|l! zWxTARt-?lMRFM5Ef~G)BaQ?CnMwpojaN!Up(Xju)#P$R^MJ}am&i-vudfu9qkr4QM5v8dZ+va@z-i(%GS{-kHpH*A^Ml+K>0 zn_-ca_e7jJX=ei{?Gm8Pj|m@_g~i`2f6@>$J~S{!lYTaP|1CFd-ywfyjobDWdhK&} z_b2*a^O#1sKTEneF>rR$nAb)=K<4RQeNr2FjLGPO3l4fQ9Qnz5-FkQZm@r>9et~1n z^*(G{WX<)Q->5ypSA!X~A-UMxYb+24K`N>g{7f7O$vT)HJhIl*nJCDGLNGm?5d)DI zCaMam8$k!I2VEiIJX-A6HB!52mW%~I35U_94eUYm?q+h{b(chMvPHdhs?5Zv>O${9V)3dH^c-&)XaH(zet!Yk&v}N=ks#r=#qc? zF!;B2@ONej?gel;*bOOoqvMGzpFfM4BYpBJ%bep7NzKY5b_ATCYF?VuC;OSJscVqf z!K0u1+_3}qPEAfu(Z{#$`^cZ{+jif5_aeQr;43~!zabR(=gD8&u?D%9$(=; z1Lwa@pX~n>o?oDEXZNkRo5Sm4aD6Ac{sO%X&MV~ZALD$!+vp4ZpR)OU-{ZF!pMT!? z{3Go1uXfRFkd6aaAu+oPQy$VYJs<|pAow{MB$it|}9aVJn;->Oo`eVR1 zKUWM8TUi_S&#S|NDq+{E)i;k=lzeQ?ObmOdjPZ{}ya|Na<<`?qT}P>cN;rmhAMyIb zxuFqM+R`wP6bDB+!q}VaV!g>;z1$sa;vOMmG^sI#dJy$2#;S{h?}Ab>c+Si_f0E6- z!-;s;v$=O0!o}3$z`J&X4ZJJYr}Fva@Xl@Y>|o~I!h$|yjek&3Oxc^TFES6OZ)LrR zl4@Pqi)dZyMYJyOi*%|48xkY%&LH+LUadyqFuG19yVM9i9^9{z&n}!AKM-YScd)ZN z@T@vBe!ysqTmeh!nsZ@stc1m}1dHQkVKKjASRMjc{3i#n4EjZXOT4_aU({pti&}oS zeo-Bk>xBaSEV+q%Vg+W>YIr3y;U#Fo%b|%ZVMbBi7mAr>JaaSPCUe~YH+M2P1r6g@WM`&d52faz+`I|c9!o-yjvvR1Ht{2;I8YOco`-BKBO)V4%PPg&6kvnIZPiVLixW zEi> zJ^R%8CJ6p)Z9cy?&+N&<93Xiw_zF`HN&kgDPgErh9Gc6H*#L*yB=%NRStHPhUB5Y! z<^y!Et}kwV>-v~m;d9%|y;ZHMlV$#UtMoydK?sajvA`JH_*SvNcvTdGn6*{4d0L&W zYguU?$5A!ezRl(+=2VH>wo_<{ALQoVs$g1p%CL`^I|2R@Qvw=%=VVAm*ajaxbQP@gq@ zzPX3`wh1m%7^|}_MePdxwSy2hy*YMyrd6p#j}HY+qaXhW-TmmxOhqi4O5*x-#c$=) ztHMFfc9H#a=s&PIgStJt5_MB)QB(Raz@Cl25_`4`mef7x!t%S@v+-AA&kR_YJv#@M z;BSi;&k`(?{{who_T$z8EU#g(gntM7A*i+iIIHw65ibSDc3yC7Iyg%P1Yok`TsfU@ zetU&zs=$ckA?-AAJ5*zZ-qdF{q&n_BZ|$V0oKP zpG8>i{GI9ZQupV=?K{M(@bEpbKM{cDjryKJcGn4Z5WvhlYCkkb?7-rf?@{8%p}@o7 z1Aq-0Vog$N7;iR%^9|Kfy&Da)sVcbHDa>ZAgfRlM$lxnP1=dLH^0UTqq6Pe{QJiga z(Og+$4AbqcV*Jp|yrwjqe@Np3zbtJ0aJ96lfkWT85YBvytc}d<{pU}8KDH&fZvQ{ryPiHhdG;$) zIQ8xB&5X`${*|F89$|FuEb^V}0`x@m73zs4cv9pGFM;QG*AvlKs3&xIbUo2sgh$sC z-V4+diC3T}ba-^RT!KfJOYy?xGIhaniTh@8#*gk}-Hi~fdPNkAy#k8qa|~|;eEqsylmM%jH? zHJ?6QpJ?HPK8q|XszEkN-*=vgyv7ucv63!i))?Hdwv9AeohuTwzAd~=GA6Zli@@aPxO-d z4g9LC�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�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 z e$4PBJjpjdeSl>yD=_jj9mjnLQV`M5{XdDd%$`gJ-|a7$!~ib*mCOZ5|iw} z-KZ4lAe|>``kXq%8?_mm6Im?!j7fycG-f}aE6PevUHbSLOZW5P(7|E5t8MT4+AD$b zYJBC@yhX8%e)`*^$8zr0okRu=z$M=KB2Jt8@bq|{M;|_%(v-t36@K^OOhhJ4E?oF8 D(%L$| diff --git a/resources/Heuristica-Regular.woff b/resources/Heuristica-Regular.woff deleted file mode 100644 index f5c1f8b2dbc554962717e3b45cb9a9f24edf9e35..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 141416 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 )dvUAhF*A_%b_kOw19$Ro!rN>Y2LZ@;n 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 diff --git a/resources/Heuristica-RegularItalic.woff b/resources/Heuristica-RegularItalic.woff deleted file mode 100644 index d2c8664593dced0b39e0d3e0721613b5f28254d2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 104700 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 TBzJ^0kbl+U47hQI0Kk6%XYVT3 diff --git a/resources/LuxiMono-Bold.woff b/resources/LuxiMono-Bold.woff deleted file mode 100644 index 8581bb5aa4584a8281f1ae761b5fe5da8352832c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 26560 zcmY&001TZusA=!)vyax5ET*@`Qhq*V*DQv z0$~9_Wff@|ez?CsvCI$j>;epv4XyR<003aZA3os+XCYCMYKAUOKQTztf13Y*6^~JF zVrOa%0Dz+YXzG9T#t2QcrKb9hKVGo09}VpP0t5hIYUOV7!z}^;>f-=FQJi`-`-hpa zz7YVRoA;yn$q!)pevwNs`yqe0A02@32c+mSaJgpIPHsQk!%q&IpZqm)Ryxa8wuV2t z|NKC6KUlwn9d@(Ucl*g}$oBudgusYE_cr?0#y_0ej|SWT(5!|JGs>_Y)KSfE1Agz24=2YcXm1@k0O9QlUNE z4C%IRsHdlA1PIvwX4!<8Bd6BU;4`NLXoNvz0sfma($m`oF@OR`)HBcn9a!O;0zRS# z0N@RQe$K#u^9JmLO`-nD{=v@ZmGmGWg-k&vJ!1gSswyd~i>xYGxxQIH(5yu+R7}4c zR+!BDUd#}*i+fB~KrngWftr=NEHDKaxCj6x6K3!Kj;E(*;-`lNE&`6|27Evt@JaMcK>*&Fu{$NMeYh$mj?oNok3r z$>|9pN^Xjw%Ib9ql^ za=A*U(`N83I|+rrY!B()72C^kj!_dl}uax;u;Du~i5%ct{j<-MND$mdcfl z#5hF#{TV(fYwI+d!^2xNr>pJu`mo&z=HP;8tZtW4S%-IQesgPat>?gy_~$|iqf|Dh z?abajd4yj^g+C_X>NYkK0QhqL=@4$Pad1jN6%YlW77z^R12h4;00V#?AZ$Pp5C~uv zkPLVR5(FXw;mi2S_cMNeGqbl z@_|p5;AX!Si=+eNU`ToVWy6xvnZpa1I5`^~XVMuZC*mty&AX4w9nr=1YywR(eaMT} zh5aDrAEQM?*854QSr|PIJG^^i`%Rb*Ww80&XEi4TMHXc8&@bD48F&Ntc)lmOAOcfN zGIBIbiMWIMycliFZp8UGz(Y_Mlr|qnl_tJZjRfQ=LCfA z7eWO;P=_-}3I+wP{-GBbA`KOgVRvodrI6!E2%@)5n4f9WulBb;V5TdZUcl{{GEv;n z45jly61~}?9Z7)aX~<_030jR&gVqC%kCRvK$sci~jRb06{9;5T({q2j)FlV5=43&l zHMY(+j6w^@*}8_ATVQgp0(1 z%K+(*+m7D;p3`t1Qr?CkShHnrtVjR3nEVW204MiU>>;)Q}{nn`%r^9MljrpI{|HA!$aF zsl0`yo}Z)u442f9G@k@!lhTmXU@nnqttt@H!8$JW_)GUZ?;<{Aixq4 z!G{cn=Utj69+0`3l|rn5`}KG}^B5cSI9l8M2vhpKI%dzs4oACkVw={ka>*K&leo+J zaDyY%vYR?7ATftkGZvC$z@#N#byFRYBPO$!l)Z{OF2n`eqm4mUDz4=nJXFf#`&dzz z$W(SL0vdCygKQNr9G7>W2GmPr2c<5C;p8y`3c^x!f^|uq9erix&uS;rHWnFyWMY_i zZO0N3pPB`Y)S#Z0N(tNx^{qn;S59)^T9p4=u6u4v)33+gC^Rm0j&3-T`cmnSi;a`0|8@}ll|r}vlAA7#3e6R>)YC=6J;eyjRH zFya-`WJvL`>g4z9hMuKicVzVT25}bV@#F&JzX+4RFk5`w9tv8;TbRdn`nRhF35ksedP;lLbi6U2^A@J?TuIl^Yh`p0fDsgmg@d>&icn(W* z1Fm7wdrK=`xQV(<%R1alF=x+9-rTeM%@{PRSUP{VbL-^t%3)POD~D#<+~;yNBa3gR zxCrm*YKVSg6+Y-L27liuI6h2mr55yhGxeS<7JQJZm>4&40{CmU74- zv5OYr#xJG6(3XCg#^BA}_Yp~cF^QYeS^e{~Zs%-cZToOjV`k4$d3d9AaQwroV=E3T zjklvGGqx|BUdc{L)Vc1jtzB2tz*;QY&hba(n3ZfFK8b^4Z2rwK52wX? zn8_H#kph2DNO8`@u%5Nnj=vWr@#OS;%joT3cowl)C}H(FReQPK7<;g$CvTsD0qhhS}9n@|i5zRt+OfJRcXs++=yoQj1s$)bWZ4d@#U}>Ku8oV>5HQz9tZvspl3Mn{_aS{zk~a>)8eM8DHWx>gSA>3sXjAlw5LKC-A8MmtbNDD#5Xgg@XsuG9Q#Hfzg)9 zevPUs2((GI)Jtd1jBa`4T$@x{>&ofR0&+E3VQPV0d31Ko_1R~rbZ!=->C=&PZrVZ_ zXY0O);1apX>=&r}P0#k_!+ke- zBzf)Z`Z_Be0S%Q-({BE83?7#_A3nDK(YxP~eOxHjvm*_GAYAreM{vr4hA2U7R>olt8KreUFZib!qCYxrs=}wKwRZ(4N?_CB zU9Hdv-9C;2>7W-|T<~G2C<%O|?a~vP$TD0GY@wUY&e3ASe`w`eGZa{nfC5At8+8BJ zU7gvxsl&6Ok$b7lNVxaM=NGvUWv+}eR{)3NMClOF`Jh%wELuMlbH}&kgD>}8N|&y` zv;nCR*qW7FYpu200G)omj5u>Q9+{+2Z!XH<|N4wvZiOrB&1_Q9Zns!E-_hD)e0?pJ z{j{p!KOx!qC7ZiRcYc*Px%}|pRbaZGA$&>D?xjCGB1H4N9DmxL^YsN}pqXh&=>MHD zDtqlQVSc4c-)E0Y^zKZ1nziV&23rP;o-02>)*z=2mReZ|l^z}q%OKq+ENA-Eo@`t1qd`*a zo&uF-s=e@T@(ZY!&II{KFOu+`$_XL6vOqX`{<^YM-|V_dQD@4w+2`8rjn&Cq|go6VT%zxb=_&gm$S2L4#^w=F;{3T8gaLDeubz z(#2!qfaUyBr$yQp3`PWDApRMcE{qA0^6BP;p(ekL)fgURo|VSlh8P-^a$Kizq+S$! z6kpA;k6X>mG}|}OtJ9gc%>W5)R7{X$pNQ0S4~#pM1*Q$Pn^_NP<{kTsjWgKCt?4}5FBeOX zwadmKf|rUV9L^$#Zak`l&$knWRrBP{CV-0(Wr`3J2%^I!Zd?&Kc^?MJKWf1nJMkXF zp86FoKt6vE*DmN0%!8P3%k|^{c$O$&?0Zr#IRshtX7U_^m`&% zp(5T(rLL?4+L!Fldmib#pGC5mL_)H)f)4r1U!An91|mvTF{S(>#%e{#g0yvL-Ta4754 zxwqNv{Z8A&QBt7ubr5^>v5UhicoA8^s6!Rz(0Kcv5kU5hf`&?o4LblJQ>Gw8YV4r$ zR2nh%H&s9t^fMNdE)s>OSZR=ftup>e24d_Tv~8qN5|yuJ{G0?%y(s{mtvJn4onr@5 zO|Z^y>1Kv{JfHYLFdqzfvG8MAOjx3+`1gli9YURmjjx{g#z5!#`_Z-g4L`%7S;@xt zr{uSn$APblxARKic?&Q1hcQIEqi9i~_v_J>df<>HiK+vd%C?L)lic!tS)_=OsY1%kgv${GuzFqi0WcO0=%r)SSTqNgbHCqB$VUi-93SzK005*vLz*41O~t?Ph?ZvJ_+ z&$h|YVYIrf+IkmADVh8T4O?|GyqXC)jia(cOYTyi$+q}(4$5?`Vv_rteajoE`T+>J zAuw%OI3i6O9y+dG&sun0FEYj^G)xZbMmOqa6iqE=IkN&MA?nKg#Pg@()kSueaw>R- zbA9|HY1jRsX^xL|bz+lEth3BJRl4QB9WPbx-w)O8Zws_lfzFzs_ZJX7@IcrfT&W2E zq%0%DHlP(*cGIGhhGDMW^7KM^oxsAmVl0jHEBk5ny0hkRh{__Cx z^9p^AWx|LG(oB7Y$7Z{Ld&VBL@-Iuv=;AU{;F7i7dqTGSm*~i42YS{SY(0U?0$YTH ziKWsfu=UcbjII1xnJf2);Mpp<9X4NW?_e*Etvh>m-?-HAh{@Unkw;O^z#a8YR?fnj z=qlasTGd4uqb&^{({sUh`3S26+K^=mDr#5lWSwj+jo} zdd5T><3DPELiIwLvG9L5T}w=Kg|(V5B+Q}`~Sbtr%+9xKMOC6;zA zlpgapd1~#Snlw1oDlqoCWQ{zF4nhZ#Gc*+3%mfJ%%|cZDN#)p7y?VrE%B5d=ofTD^ zzx_o?O8dgaSAP{uRHr88;k4I*p*&(T#vnip& zQN~ki^Rjd(@^>M>-&yc-7A3R-pG4fqA;uI_(yY|JLEKP2B`4I7Ur_xQHK{6SPzWk? zZ7=Fop_=5N<{5rS`^%(J%p2~oFs$vs^(z0jYam4I&Sl>&FXgG5Z}I+zh&aWpnMC+>Ato4+MC2%qJ}7}9(3pe?$vFbaSqX-N_yrm1NPB%dU0$=+X69&P zMphhSyJk&oDhZIe$%0y=3I9RWekf)0jmtAAYy( zpDAa#0zb^^r@4}>Onjn5vJ_P4C)R*xlSt#%g3uXBP$qmu82B@O!RGKUvf)F`i9pFu zLdsMAvH8m;Eyb20Gz{KYJEYeTzAaZL*HyI%RBA1q;8;6zRU0!rT6hPp$q65ZgoDt8 zotjK09%Gt3C8Tt~(%H!p{rp1Kp3qK!R0K~*c0=XQce`F-QEQ5>j?9k88%v}Cauv>* z?O=Qs-3-+b$E4+B*RNaY+cZ5Ufm-VwqHOzV} z|8?yDtzCc*)TYfFMbDq@YV4$Q zi>dY74k6{L-A65jF*2%v6AlXQyB&(|zjFE|O$-`u#(_^?!rc)@gKb7m*}tZ>R^zek zTDHKk%qf0Nn7a^KqYcjY<`Hwf`_890r4)LJNXE9b zN`xQ##TCEl12D|JSWB{4o5)?D0L8T*WZ4V}Mn$L&xn#lJM-8u+iI^{M)UFZG+OP}S zn=Hc@VM5Go46YkB#LR~c23GxwSKq_K!;f33Qgxzne^IIu)8$z39{gTXxg*AEvw0sM zW6Hp;uWlovYV%$Y)1o$8uywYs<><%@b=>k)8x>qWy9Ddd1ak0u%sXT9UEZ_pL94{9 z3n=TT8aUb}oi0K_nA#QW3|gK(9{EK`%DN&?<);ztZB<$%+-n8`JNWrV>tVglm{gwK zHzK;WydG9v$T)w(gCO)q?5{%a-`IcWMFYUaF$>Dq&dM zYa-m=+hw+Om0I~2k{`O~io2f_bsZ);+>!xze}7E4&A2XP5wF{?2Qr>*lyZpwPF18O zSTJF_>jcV@zvhX)ZUyXwwpYXMknFT>W?aMY_@b3@4u>}ADAEAqHzDt~x&67-iA5+e zt9nR7&R7CC$>UO|sShjqU#TyZc^*{&ij#eh843=$rq8 zyh#!+Xfl2Xh)vnrm6>Q^Dv7;`CJC-Ebi(59i(A*N=qBq(BMh~Dh$lmcV|{;9ItDpg z=F$3_wJs8K?BKhZH5t#UT#AlCd9+=<>218;r!`VKf*K7zh&om0U^3xtLK(ev?C$6; zHB$oz#||S1K$7JZaM)r8J$8b;*}uV&^iOqB$h<{Nb+xdM>dI;8&VlG@LBsQg_-KI; zR2pszLeB!0rKg?WLC3S}Ri}c7rYKKyw;*N{zFusAwpLg_e9ULh6O5D~Zey2p{OUP{ zDd2z1yIQ!e(6-ctOk7zUyezVu=h#AN-+bh0W*tXc`6i8Ojd;gTG)|W!aXb!3AwqyV zoqS_T2F{irdTf2+cIlHr=l(~6tpxg}yxj+^ER5clMl9feL_XtPV|Fgg2cmaT9HHM$ z6%o;F;Px%s^FHBvYV4bMVWmJiNBX`8k91`hFiQ@9&Zcfb>`ARcchB=3{i|o}chDCz zqo-_va7;P@X>jqu`{dH_fkWWgr78x*@q#eUE8aEG)oo1G#No@>*f4H$U3NZ|GXqac zzZ?9Z+n@Htj3|z@sC6Mq6O||YW$)zOveQvZS_W$19B3+T#3Vaa zCxSg#;pFA*yfG0irgSmuqJ2J+QSftqBn=|9YRxpSn20e~Md0_|>hh9sO7|PQ`sQ4| zk6HKL-7QLpu~_Q)Wk+gR+PRCCuM+F02TkcM-TY{9y@5n7v;@J8G1IylrZs9JweT&4 z$%jzH^*u41djyRdJsui!c8dWqrKbMcQdeL|AudbX^vUm$%SgKCQBxY5k}1tO(y@O; z!zaKk%(%c|7O3K#s9D(a_3nr$dDsO1q#@i)(D{pQky_OxL|U2|vIZLn;*(^epr&=# zB!vFGoT)I}4YsoA^Ne~$e}pS4e<{!VKD^u-o^_n7x_&2dF*YP#@0+413~96H^`cab z1sZ3lP%Shi>$Phy+9*Y>!@)+hE4ar)N1q7gBTWX26fFl1FfzeK_`QB-(%0jIjtR~) z(@5ehxjq^wn&g*Q&h7b%`I9k}`MGBKTN3~+|WJp;= z?Zt_ro5;wd_|jWZeD7Up|2VW2C-Izs^bM~n3DPaZf0M&3-WPcz`F?NL z5TaW=v!l^-*Fy|;Q#77L1bT{9SohTbbTy`O8_M^M66wp>FeJ}Ez1R%HQ?x-!5!t)%FJt8x*uCW?ZnLO-Of-_H2= zUp;WpV^a;z@speDz){|QC&S?1ng|rmSNiNOklV0pf9fPAWpwdgGD278{FeGCrY{d=CGJ+q3kU$0|NWPxF%n|4K0L zAA_l82OcwXdhgN~AQ=`Ya#5f8{ zL0fs&Xl*oo+P;vmHOYI_m}XM_(f?MMT2gtgn=YiWu=Q+;UFzkvyM202+Xd4EK?>wU zG6Ic1$CQ|S$X!1mZ{Js+gJ-x41yuz?gK9ozj5@ucRz_jll-y9jQsHQgejkk%j~qEK z@1@p&n^RQx;HgRz1xnjP)09YC>3c8Pgfh^etAKM>!pt_>4*6V{qRT)srhh1{#udN9 zp4CKC$3n4^rTjpL>J4{@j|W>El2WylXLTYB8VIRBN7H6LFdp48c{L))sWE3p5rvr? zVec+|ScqUtx2#vdPSOrEVsh++=>!h{%;b{JXiArjj;Z0*ozrGgt2BHTYgS^i`Lv<6?Mn8fS2W0HU$xyZSss z8lndlg!a$o z7vq3-o!FNp8)%z<@Rh*RUX&={z)|NkP0>HBUBNjr691^7zP?!Zaz-hhyMAdEk?KHf z{`OvRjVe}-Yh#YuH<@EAjeRo@Vc?yvim&<;Zjx9sGxGgUQ3DsgkJSSkXp$~?J7w>a z_v?mMbs-X1z&5HUoidc-tOj>Gcl^VELaS-OG{lLkj48M^V>gE=d)JX{M5`r#lFCc$7xx+bKr&-WBMJmyct2iF+R5YyX#X`w=e( zQ$}aIX?s@~haj-FiEOgbl=d&f-HG;@g7&Emvx5O}55nt$i77IM<7k25-cMs8LrEYv z*;+{c6r{F&oZbr4HEGR6{Ap;h?1I{PKO-Gm!5$K@ByLyxqloEXcFP*&*pzOOa?BG|O-QEZv$|+}>M|YN(H?BkYSR`k5 zy3M#8#tb$6#4js;y*JI@&o+1Hp7jCHS-&2f?fzLmMRpsWLHLd15;|uINTn4XN*@*6 zHfr{bU^P0am)inP;7uEozB|@$y|*GsV8+kipP&%F61-mDeZ9UaI1&euDO4~_L9eN0 zLE*0K#Djn|TB1*#I7qnJ%ouX#=edOp@VV2cF&1?iaL!{LR$v2Jm)Q261AMh~_MI-+ zt4G2u2M&^Th|-4t(FZzCVw2lR%>KOKwiWveOs=6?rYVox>bJj~f4O+}DuqdqcWP&l z_h`vxqiw&*gB=w|96H{3M*cc57UlEVob}YL`BFy*wX7H$mi4!zYpzM@sb(^lMzWhi zzzkFUMwHj66psPPKKLO(9I2|xsIo7aLB3U{+y6y<9Ni%#i`~~c4dFbecY6>=q(&b5 z%RIp@Vc)D9doul0%?mDe@@y$XA1f%)SBfC`QLE(G*%1z}N+;3mG2?0OjVWgYL*g-` z=C`^?g$_QGQyD~aNBv6Br2xW*0rxX%W#jL~Ibnd}S(GIg6%FD=Fk#MV zt(KUh(n=uc^$L34X*I1D^0~y3LJOoyJfOWiN501SB^C`i;uQ%&6MDbk@vwP1Y@L0> zW?|Jfz4C{;$&cR2+}g|O`s;m3NCclQL=}4i)4;@Op#O*=JU`OT#&bq%T{yy^v1^B zLYB*QMh(o_4jw`@8aT0HpmcK4q#~Bl^bPjsd)=msJ380eB{?K;{W+cCc1Dj5pJ$t6 zciv~kJCztqBtV~Myfbt!W6%uu?z{0W*3_SyAh6`9LM$G5GA${N2qGG_YW9PJ{*Tv5BZlLdI$Y;PCR4R8l!Emc10%*mpZ`E0_I z*)*(}vWL#v*jrW3#6E$r5o3+a__@%zTEyulJ6!&CZg+b5UF6i(xV`D=-y+Z3IXy=F zojN^pcE}DIF9M{ebhi9zbtG_ifVnLTWOvv)_@!kZlc{gbrNz8V)CO58IHuBNZ{CgBnccY@m-qckj$Jqcp zosXxr!cj&SqVcwp?hDG}S6?-4q}Gc4ce~=X5#^%K4{eZ-je`Am0n{V=vn{xrh&Q9n2oahpi)!>^^B&`v5Zc`c#;1;T* zgSje5Kzx2G@_jfRp5TI{;$5}qO+(st23>yfyn-y1n`?jApCe-U+I$3Hwm3+}nUz>O z>ekJH9W1HG^wktVbKJY~tGq&sFzX_wPp3RJu7zaX8bApE=PUCeuMWFGEGf*fSo<34 zI-9%p@AJ$r;DMTD;?1Px{?$({|4zK+qLl4{=V*|C^ zpX67I9nGYU4qq5oW?A14RWFRQWxVViM~Mr(Ot#7Jtnq=1A2mRfI~2 zgf$ZMhkkBn!A6G1-S^)%@7&oiqBYe}%F}8+KGHI5aBuCM`Q9qCk|eZ17GB1Jl8!b9 zOSor#(R8z=`Z*?iu>?4puU5j7*7{&sW(Ia08eO=F0&J3+XHUt0(GJxy!mZ^u#ZoFW zUoMT-#(?MJ_I0PVbu$+3F^>o9r<6RM-^*tn?IZg&cCS0vt~Hr0i6q4(oc%}ozzj^v zl>unO3i276Nm~?~;zXW`?kHeQzarWD1$@;IsKl63sO51O>f5CwdxuWN)T^;#Tuf$q zou1Cb{K^<#9b;>imaJ1>J;l0Sn`d4L+*MMiwPnj}tMSt;)cDBr4)^swfNa@|SuQ7wDQBnsZfL@4`%+DR0&u8HjJTnN7bf} zZXl8t0O_hz{-nJd=V{)ne(*AiJin}iWq)*LhO(lU<{rB_{w=%7ok9|!_|lhrb9k<+ z;rXFoCngnYSPgyF!C{m6qpvo0H`R94!po56gBYHuzmt3Z@U!%E6r5OiI!BXqO-gINrvHEc!=3w%v z>BgGU^Dj8gtJB{LOmqvjPs~hDP6T+BW+L?=XmPu`_U?-2w2(8Q#1ZtX2#$oick;WY zI9o6QzmtK;YQyq9yQ3E-EPp;g*gz6fyLFW83I~i4QXjaIej;$zMSGlWwi@MBPrf?t$W z_EA}+IU!ZC-KVtA1D~j8>xE4Tbc+SP|BAOXGDJ$(MZ}->ZVZ~Dg}vhzHj=p|n7XH% zS{PT(9~sCl0z=4*4aSKERdm8x{7XGqtT!GSIpPguv&Hi;*?>p`w_&gb8ZsB?C#Y38 z#!_&*Ozlq{{u~R->t?CvdASl8XteuFOR|k6uGE^2mSDwKa0^4%rYXDWrBQ89L7ztX z)GbZQ{l$P@tR6jzaw$N$?xH{?u~5lv0#uBCy^%FMPNf{dqwexdnTM;q(RIA9!uEYb zgJ1_7fOlvj(!gElvwwQ?EV4cCw2vQ`ZjK6(v+!>lDNPhj;66?zeR`+v-tVdwUv>rZ zVn=Q)#;3N$d7Z|<3MWxi@RzNV(nQ2t zC?_`fFZZl?r;fsVMo$mVaaaat&6No8J+-|2)VXGull2-|M;#lU#sy5?K5rH$1Y%=! zDUUksP~f{@S_;pZ`81ub{7sNY$mEw*Sy)a_h3wJ?27%WELXvGFS}s)# zJ*gyj?PhnKR7Uo04}LW_PnM(#!LOYeKVXEn@OglPQ2DvF!FtivDcDNJI^RpQm9^7wM>>MJCAw(tv>rWi3FMMyCs3*x>dioA@Vt{^vBr;fX6l{#4*S6u=hfjkGzd*K6^8Mee4&%2tCRnGamiT> zJemBvB;(}|DHyNm0lNe|TrZj*KL3NFZSuzM4rS}yRQBhJLNvXI9*BHe`uE?j+>fJV zG^_c-@Mw;d)iRuIUi&kwme0P3VX?I78i4>@1-C6TpTeYZJ*Y@tM&>pmwxX^we~79db*J&#MQEeV4N(OsYW@#>AKqUvqJZVh=_BjV>}X_0;5`cA#r}yi% zcAi$^`4%%3RbN+*xwxL*ZxRB{MRaYJ)wSDcbAmM<3b09WH-7F>0@^3_z7vPF5C`%N zIh|!wehJAgJ13`J*1acSZSwwOO+;5P(3Wu=NbzZ8654o1@iiy(v>fpK0>6S$#qTb# zlQY@zU-HZPgBY?J;tdQRq|86-t(=!{3_7Bdj%>!b=*3v|>B3S29(cWqNR|z#)GKlx zBa)g|zvt>Ud%&MrK=`?@#D`F-ABl?1^C&u8S@x`>VkQ&BM3u9-`95Mnunc2(om_h* zap{luKhJPLJ|_b&V;`I>oN!Mvn#;JGxK`$Frzy6?MmJXy5?g((&YnCuu%yuwvIo4j zQ2)lt+7T{b%Jy@G3~R%J1?~i9rrj9v={7BC1oNQp6Fa~tlxc%zWn6g~U&+?ccO9V^ zUlR?Ri8%JdVM$9pCe9;)nY0jse{5-V#Q&p7<4${M8jUoDo72d{B3uk+G^z4FfO($I ze1XhG>Du!weWcdhVy|`22b2lqu=dh&e+uc1h+=G|r>Ca-C^Q0TcyG83k?$ks3Z=IO zft9HV>+FuPb>e;4briOvG18U?jEl{_E?|E4IjU{v=1J29=rP*!x+2asxpQ#{&)L^q zJ)$ZO_vy3J2N|y*s%T;lhR?M)S!OaO+_{_itzpuO*c~Sz4bHBEgK6h^cj&3@^boE& z`B|;MWTQkn#?FM@bzhQ@OCS8xKATw0O6DZ+-P>)fcwxRfS~mJce_xr&DPFZV^nk|5 z>gDV#xUnq#Z3uPhZj60h;Q1<3N%>-#2l1GN^^#-3eE|~^ocTr?op@p%rJl#!@*--9 zlvmn$N6vEI4+_FHq-|MR%H@mEa(%X68|y~}UHW|k(ZULQvLXF!Hqu6Ivz=5Jn2UA;&>0FC&a9q4v5BkCPB6JI zO`q0mJ#6t6^NyBE-?sCW9aQ>~Cbr4JL!pepX9-qz*Zj*gke)FcEJd69wDg7d`nDa~ zK>yXcSMEsBTV2$=XB*(!V=gty1luu>Y~55?cd91M~i z9%<%E;^O-?aviIX4HS2GfV)@FBoT)udBf7emC^G^t5vjA0Xqq#S=J}%9IYb_VvooHCvoQb^Jg&NPQ|J3h1&L*ElgVIwpkgO) zuhsF4u_W)hw3nz=tgrsUaqPqX;}^+!Pn-R&*mwNZ70E{^hIDT0{oEm^sf%Kcivg~Z zFD}(J4(_Bw;iXgTa^+%5oj#G;A&JZSI;GhDNCTsCn9_nHJT~R9BZ~?(HXCKA0uv5Y zOa-SLl^X~w2!zh=GoV?>pD+t%u-y*<*1F#8VekH&;-+fpBY9n+Uww$Ni`VgD;FF+k zmr6lXhwv1BQ|{FOUpW84H$sFF>CHETZCu%JeP}`U?c*$8v5aU*wN3@m@$XqX${D@} zMk3khuCkV|!Do(^4Z;VJt-Tjk3BAKU8+Jc_r+=n!Y~<>Q)&L7fh;0n;z@9E16!hfF zBngp`ID^0FcwA3KZj3wgV?s4m0Y?&A6h9Gnx7{q~1*GxyoMlH&PIw=z=V^qNb71 zLr(Zh-{#X3-@nD?7>DDbNziuLLxOgbe}hIq$5boX7MDFB#8A3oBBbzX49rX`+6APf z%&a>N9X!Vgh+8?tF&bN-ns$b&vJwu=RLtuPL9it+Xr_?1#X(xYH-*M1kbW8lg|@&@mKf2T>8Cq5lxR(0h5{tz^@}dRYvQ1dI$R}uIG7nP7JDD+C=w*+$H=+ zf+ajtnPZx`rL*9H?dkV1C*)a-F&NJ!Msk%Wh~UC*Am`qW*do<*?016FyAN1jg%dCi z)qp4O6lVcJdJ!p$Voz`WxKD9dt02H6$6B&jL!Tw*-$LQ4811hqe%N*mOgw7w3&j%t z7rOpFUXy$~j95mg!5Nwo8??sYs}AJ>z`{K^?d8Hjk{RaA_|x8>c)9XA;)D^Eu&{cy z6^!!L;#z4+E{~88r)gQvBLwsqtyi~M59OGNv*w!Euf6Md+z~_EqAJ?BQ}iNQ!SCFbzyj}*P~2XmP7(8pZ(}*uQc4% zsvH$rUU45et^${;P|iOOcjQP%sm>O^T^tMhl|T%2UYp zMn!4@0zMhvN}vpl%!pS+qFPf6ZujME`ov{RVfM>!e&>UpoIz3ikwrNv7qAB18Lu|C zn&o4i+p-T-3RVXJ_FBopZU_;C-%WASHz+6PpDfFZPHv!5JmdBFxCNJUk#AT)i)@KS4#$8I2YR z85#!YLsjW#kX;0-E89hibYm@V3AL0ogOj)2E5oGhjVN@>RRtAi(&L^OpmPqSDY$dO zoorM$$+2ALp&`P@ai>d~zthfFNlKKn{`<4_dQRVP`+Kdd1~4^f%OP@9xe;5wG4A!t zxAy+nDYY!-gFO|)o_i`OWth7Lb9^_Us!|uR(?h?KV>)@!;x!^7b_66lxey2aQ&9A) zj}Ml1;!Q9j)keZd`P@U*K&(&oqUho_z%?#3(U?tl>}ZeaUkZj(K#$V6>_}Ik7#Iws zIYnu%^N^xY<562XL$xBJY@No;atk(rwI}jz*Y@YTnC5j)4$a1LHuRcQ&S_-LY#i&0 zV;~63<@RdRtA7rP`rT89Ib4erc{RIFC~r9@f>XtD&v+csh(Mf-e8ow@qscnq_@s;n zG@eLxPZZFMQ;vzfSwfSz4bQq zvMxoC_1A%g)WEpB`0|2=_`t6%6~^^Y=m$RV4T9436PYflj*{s4{p@~4BY9O16Ip|h z4hLEN%I@>p=XlwfRkm6Ly4R~1G!|~vu>_Q7Q-dBpXU*Bu6TNx<4$dv&wRKNlJLu9S zkms0kh@dU|!{?9sW&3x1d{ z=5WyjjQTwYaZrWAENMWBS=$%Yj(TO_MPaB53VJZ(9l;j=6BZ}w*#DO09c}968&hDp znA)qaf_cnV&*|RMp8yGA zz+MrhewlVj(QCcg#Rv`Xp>*T__3`@IWd5Xa_d3RtS%bN6ues->u$FWS27cIKm^-{n zu!UofQd*N^v_#$Iw=CMF%ay+8UaD8q~tZOHA@O-p-LAxG6Qy}Ee&i+6))L1t!?E??o}J^ zze1i|G;@i1+(GW@-n%ULx1DooFBCEjbk#MGK{L06W1DN(B+v-pmTwE)Lu_E`$Ux=N zfQ1V>L$OK^yx0`2U_$j||HR>kSrS5^UaqcT7_$}nhG9O>O6j%O0RVZ)m;ryqL#Dm< z8u{68_;cIH{^ZsNMpo0B;vIl9lQ6Cdz#=o*KGmXavL!K!*IKHuz#Y!m*Hff&kG2WB z7GXIBHbKqX1UI$pL3hbIxym}rm7Aw{OMR_jNB_XjP7MqUta|0Z@~v01ljii?(Mdk@ zgU<-F4=!G^WZAyGixOExcTW>u{ z4yYY(lSb0GS?y5od9rlGQS220?6n)_i?LBR=i}aDHO7j;tUUoh;f;W`EFOc2g)S^C zbRnkl9$Fvm0jr`AlUQ>osRfQ{R#jhY`JC6&5)D1}=;5gq2VGf|7zykk6?r>0FY!@j z=|kDFriuyKw#R;1N*$Z%+M36+hX;%w-rth^x3}4{TbuNHdCS-}jFn z*Yn$Yu3zE1ujR2J`MC|`7i!&xe0~E7QeV&sw9IL=tml3We2p??PP09mby$sFBB(Qf z1Vu+>Jho0n7siWKh+_#Ezda#Y+mC`rYq`$?pdkh?VkxvX??*k|5R#{ePqA7*Z?CP> z`iq6pJk`M|t0T<(97PPlU!PMEbO2rnDzh8u$GX%OEi`LQrb8R;B%e6Ch7yyvXP5i? z=0@txpWQTT)qT@9S5yaQRFNrTNgKro3@ELaCxB36|eWEtWT6#w0ho z6Y|6q_T|URO{x6&7W#~aMqv9Enq6zbtmU{ACeX$#T(n7!HOWzM{bAw26{#D;_Tzx< z8xAQcWcwCi`*AJE_R+dneM71YR(YMQtjmmz<2WUNCesWiQ?A4la@a{Rhg8BG=v5T8 z6ebPQRKI6fcYmYjW@!npf8_e^-5;9XKXc1xS{fGQ8XEV^X`I}~9WNgF;jDI5LAgmdn)^$TZJHeNe$3wh$XrRq$f6YxYetn?SPj#&YgISGhz5Z4EH z2-aXeC#*F%rGCEF42N#V3e$ZZxJnl0Lui}L(V>?(`n&^dv8Tsamr~(I7MEx+4EKA$ z9kgIR&xn+t)U2A^S*t!McTQEweYSm>F9)t7lbP|H;N^qpa?oMrO_uX3FI)ShD+#Q8=W#QEN@L7bO1i1U^j#QE@vD)`DUK5Gz% zsmrnkarlIk57Hpc6}@GXxJ4xNv%%NKc8W8uQ(wH!@qPdAbh)8xp6tFoUH<>mI8O(_ z`qs_!mYpJD_2AeRdSnN=TYd3Hp7C)(?uYM98$YE@phO#RPhIKqnx8S`367E{_A-uWVbuwg9w7&?$b z2M=m2G=@$SxQXD7+=@k%RFi z*7p;;6W>JAiK8T)_`M=L0g-sCf`BCqPJKb5m(2b#^_)b z+i!3?T}Uf5MEd+3Cwov1`sbb$hJl@8j@cK|&@Tm-n?a7%jD3vA~CLd*~xkCL;R z3jsO9B{k7RgLBk7Wc)tb&~-euv<2_&Sw1pK*vR`4wuTb6rbO5XKAQ_)fv`1^F@&wg z_hSfKTO#auX~^t!nUK$wrg}IldbOhOu~cqp)qFCv;rP5X-Po|mcZ_cyIb*Ow}mIK^ZDDpdwcRMPstL}?34cn8#SrKPCtF0z5&zi;b>3%UIx z8!mSAgk+R*_24$OdQeU5RQHglwJxu$_tQ+R?`b3Vbq&YW>9y3tO&uWR1dXy$Hft(x z09gYAA6I%ZQ(1S)BtW^E3dvchiq_R9Fn~Tz%3J-hvdZ@A1R%Xe`kqND_H_h<#JpuBzCQ|uscL+jJ)OTlIj-rN8c zA>YlkkpGgj@c%_=A-cd#_9GdxiqS2-A0+_d-9U+vhh8RC>fxJ7!QjgcveVQBAQ_rf#Mi`kJV&fW|ixamXrGIlygY zH@qiB--}vWS;9@Cb@9S4Z$+qL-GcVqRNyBopo3Yr?cOR^Bx&;M12k}zwC1Uby+Xq> zqpe&~`peq6UOx?lf3dVxwtv+H72zHfMI#GVGY?GlCy}y$Bc}MKsm(fu3~ryQ zViDIdtyMqJh=(f7yeXk2127I=L63$+dYZv&`V71qCZcg?`9zLg1kg~L!ze#;T2ELf zNbNGV&ykkJy2kdnBwPgurd-W-fK}1Q%;Gbb_!QM$L6C8}gVR-wPg`=8p0?x~?R1F} z#ln|fYWV~BEXy%%$r~_9K#Hx&5&x_&?@q2R?jsFahw@{`_#HWNdbCS9d0Ta8oyyh5 z+^8Kp3_RrGnz`TK)Ik;TH`c9$!P`uR>rJexFmmhGs;LjyT2*dF9pYyC#GS+^T3T7E z;{AHA4%Ir0u&5C&xS7;Ie(`~!AFvgx5@|*x*_h4VrYWoDW?~`PsF$f@ZAWfs*m_a( zFx{5SxG5$7(qa{aY2aes)Xuf&WQs!3#WWdtA-RG1|Fq95tOY*TC4dZc`K3eulFIXxBNpw^1g7${Fx$7$m@@+c5zJn@IRd3z?)o_RU z;`L`oTabnn{LRLu((LG=0pS|e5e`**7if}eETjn<^iB2(_q1tDR+Iufh&dAjRooUmk3o>SbH6arjv6;nm1qDebjXh)$2-r?bF3 zq_!FR=2--Z7BRZ@3Y;mb)Q(#(g79Bj?5J!Z%IDI|WrKn2V8~m1}%s*iAmr2?I-4xN=fSvDej74IdEvm z;|_p_?4_?h`s&A5EGCUN*2CKde9gmcWkngF{qSKa**sjt_wg(@)#CPe1NHHS#!?4x zT333@(=@RVZl=ADTWF^9j+R?XK`Ek?9wY7e0OvT9_}eW}F}7r|@Q&J`do;Qv7)-pN zpAwlQ+;O|r(?U&x$ssv3MIZ=*4pqSz*%GuhjcPg}#C@(zD>!gfE7RzPqxlS`N_wKm zt)L`^98S(uD&Qa07(*eG7tU9*^OZ?0KSwzln+X8rSdRF1`UB%X8fnm&-aww;T>NTr z@?_bC8|Q!V;^;Jqj@enlt>#t+X_zp zT%nhB;*g*-!DXF^UKVb;Y%E>2!W*jrFPD9}rS#=+*@Bn3AtD$pY?oE>XtbGLo0<5` z#Aqg~Nw2zl1DQ)cxk=qc=5A7-g+Bu6C3C;5?k2roR(GkpH{v~Ix=jBj^~2&sVs$PG z=S#Edf7->-Vug3bht=pXSBSf%aO+%pV;=t^V|42`#KF2W6}P@pqC?nwm$!! z9f;*vlJ2znvzrjdvHuA^w5t|tdh*da3^;wDw#0}FZrhspB8ElYr#~^ju;?@WKg_%K zFF0?z9+tm0N<(aJNv``~^G2WRw(}+{SV7r)&z!`IxT1XS4cL|Ez2`2+*zT)8d-{nn z%RUsXt8YLo;&#fh4@QL|F1alw4q-NH*8%>;4@3**12S4fDIYX&|Er7|wP?ZW(^%t( z7A&5+WmoR^q0CUNzQ#l=qS2Cl05T0Vxb5(PdiH_(WTAnXKBQiKj8&3-AW_kL$lDU@ z^o0u--O(D5FxpT!4m)qL2D;&gKZ zV)B(!7)`uYAL5emj6PEW5&4R;h=FTNe4ya;76V}gb7=IjMAfCZmkA$#F#1?28alW! zdWhY391O^FO2}KMUN)QN6zl&1m^>e%k6#E?!s;1t z-}?lug8)pV85Xyh&Y?MtorIc86KJNXEv>e1$Zi_XgaE61W65HjZ)FNgKLZTF2a-c! zdYg;Y17;X|{Oj+3_AQ3oqoN!+q*OStbI*`iL7QLTD_j_=jYhy!!^tvJEoDK`MriSL zg(yX8qs8Ls@^{oG2e5yEAx<-2^0=%Lw!?di7cDdi(ZH)bLCRZP;cT(@k>~_+v-SmH zUdwApw89uSZn0hlZ7sOn0JpCsX8(4WEF^Q{Q%Ewg>Xn};y$g1D-L84}#kM_7?rUf# zYkC`EkLGl%iI4E=H}%Pi$N^<8#v&b+0GWy9TfK zV2tEXe`5WF4IN@V*THe3fxG9}tL@zt{P`b(wri!H2{jNN~Z_AyR# zQ@Kn3?Ow+6#AM+PnzxdtBnt^GgLU@@=x+=Lwa~)ewUl=|mM7zHH8Kxy+Gyuvr6tZ* zbF%b;xn_J~qKF2lmTm!Wly2^XtW3EBto4M(csBdNyCUOlDen!1su?U)egA&Rmd=hN z>+k98>+YDfEE;Q0MiZTjI^Uy-vhb;S_jX`THT$7O>1eDfc4y|^dy9CR^(L<8nz&Z( z6)s>;dnt@Ek@mMN2>`@*nXH3%!kH&$aK1J?IOPNs_c?BYzY z&GB1q2#br@;s7^#shULF)`z+%HB;CutkQ8W-)!t2LtnYltnWihIXmY34aMlb)X5 zc$;VQp7pEe^!Af>qPFqzbpNt7`&O=++me~Jb;ZuBGus-go+i1Md4uFmJV>%+`r2Kw zxmUWDFCRJ6vu0ZF9mm_rv{;u+4)0hxBcBUC*EosFOuIT0X%8~fNoA(Li^&r06G&xj zI+NAcZhd}b|EuBu^~QkTu^ zg8*JiEmk#^AN4rR;*iOVHEs04 z@6dzi-A5);-Z*cuV~c_08`*Pm=HM zTsR**|2cgRBLA>H!pJ{=#calf8~L`I@!{TEpI_N^>+@*BZgu|0+>QLt&M)Q|-!6dh zED%o9y~|cE%jE@Ba(cFDee}uNrX=p~qTK{-xLE^3Hb$Dj)t;tEAG57J=X`;{jV!@U z`6Q0}E=R86wtU_5tgSEI$Bex{`#2X@#ns^sOtJKoD{N|wEy7sO>R2(Pp>#*yD*IkuK*E;tS$_2IPn#)dg)bP@oI=( zt;5$meDJ0qrYW0;kK+3fn7k}@d7Nq?*k#S>^@Zxjgfii@6+5q$pJtonvEJ7pB6|kH z65IFgYpaj9U;|86_Q7c#CTJ5L13ncJON840eiI=rzu)zWRkjwq*8ky8RH^1k~b@fP34?lV4Y;u0q;)SYbHu<-~IkPE0&>n)6 zPi8ZI%X7CpzjFGm&mX&9cAoMTJHJ?E=V@;d=3M3$SwGsT&Fe2zgLL@k&_hRgbiFh zD2p)d9iRyQR0^>Rf*H%rr5!`=3K8s=_vSi;iRib7S@nhzW&MT}s}peyxD$##K`ZGI z$HY>;j8-_NRVvWpG2Dr#t0$t*OI>}|rPvT4kM~XI@85iS*_JKK-rYR1dDfhl=iNgr zRiQ$_Ss9wKDB$GJ>zt%BqCPiREM*u}pNUQ<+(FW*ZXZ~=xcghY{qQ~0cdkG^7SZrx zkgMY+podSNxf)30gA#BnB7K~4wZ_DVxa-IT7Ze-o*D1#&g~N&% z)A+I$O+JeIq*2_5t@fj}JWwqqWq|uhnxZ}_($}YKT-mdRG^+D#;q1Wdhx*s->hIlD zIQoCfyV}sEt}uMxb8qfVlQg|a^V!tcn02LeE;F$$BKkwhKq<8Zk>Z9(RmeJ|t0K~s zB4Z4d{c?`Y$%G;OQ6!V3mNAMvqE~# zO>*x&=j7aT-p}U&&%xp0gK*=V5f820$yS2*llv;B9iDKSOkRBk0$8_WIIgigxdwA`-p^X(sQKijAx1UCS;i|JR)KHRm_ zOLAyAAD=tJp+stlQ!2~@+$wloo^Oi|ls+;~(Xnv$6jC(7-S+}?1u8MDy;o%F@a(lv6 z942_`m~Wqc(r%1qKC-~^lvlEvyDwdJ?t`hEdNy0)&-WNE^5?tQk%4_(ako!jef0e; z`??ZtQ+V(HDZa#if8IC?8r#@({dqm&yq;y}jq3|6NOU%Yr-0{Oe~$A6o`O6L=gORZ zRuAI--Kgaxnt~;B)%*(fB4%{SqU6fXdd0KWB-4V|_Hd|0%e3$TnEP-h=pP7$^dl%8 zdae~Ga$SSY^pgAdwO)-A>&Qm(TQx~wGg=twZla*=rR>r88Yi-E34V#w z+d2wEyIwu5pPk61hhWHge7}DK-H&M~q3(bo>{nJRS(z#W1NO?|8F;$5l_;n?W!(}i z0k5nfJm-+vCGW^I*m2@~$UhjiO}xe8_2OhMy&d=Cd40j~V4u8Nlw!_wLuiGjFysWX zB`@bt7lL*voRw4-B*zdql{6H11-~X`vD+#qlU6m(qG=N{=&CTvH91+gus#pLXt=;8 z9zi%1904|=FMtpFMvr%*jIJs|W~guDur^~EoJC%tSOu~Q*_f7_poA6Utt3!GLc?yb zt3+}c%0?ti_+VDD?W$mKJEK}md43)A8`+&utEc9JBkXNd7=B_NYB<*J>kFgDJFxQ5 zxlpYLjE`RDrg0cLd7F31m?s=Z5N&SE62eR%M-!E&W{4J>T(QuxS-M@b#t)Wby2NS*XW{=X5K;5yz66y%jb=}VP>F4WFl?U2I3zV#OCtbDr&ozQ;F$vcDpcU)3!4ZCNY<-EQxfGse} z%8?k(2ERy-a5cA3f{sEeTgxR0oSbDliC^-HFIj#}%NeC8Dw@TcIS2h02gTE%KRI$-ZMmha5N^7ew&27B6%91 z|Hg*j=jm1TkDWvLs}1#tFXj3b6O1pBmL&Zw+^_26SdL;zoADSzWF{Un51+D}$1IeU zL^!k@Cj}*Yl53I4Hqs)K_3kn$!_|ga7s|%6yO60K{Ivh zqkW?vo;ROV|j;HO-$j`|J*_zu}aoVY!*OHSuZK{M6@L zmw)~z{HN4{0001Z+GAj3U|?W0Hok82qdlJA<|~6e2LlM4w0LQSp#KH%8L`h}U}WH6 zU;>E(09qvrX8-_r+GAj3VBnDa7r?;4m&U;G|1X~r15gA7yaoVf`2`Jl+HI4uOT$1E z#^1$M9YO}_l0iy`OhqJhEY?%uuk?%nwd83{h`Uc_H$)CY795^!#8vH|-O^aZ?v891e_ zpz3vpW-QO(0qlV<&?1PpQJE9gQrsqQ+!5Qc5`RlW|pzj*j zO)wX6{~7nT=bh5m=K2kOS&z;MwW>FOeAPC_xAb2(`i{%9z@$ z5Ynf^dg@3j{jf|c?AG+ol2Ka~?EMLxezr|sY85Omy^E~eh*e0_~Ue z7Y;f5Qr`DQ*Au?2d84avM^sP02knc09j~qTWe$m-{-0+YW|B+(2Py6Q`TziU+GAi~ zFoMDqh6RjOOdiZk%tx4?uxPO4uxw!Y!m7pU#+t{vfb|=j5!)Pg9rh_492^}S4>*fB ze{kt=m2n;6dckeRy@@A==N@ku?>63Fd|7;#_yhR&@&6DA5V$3%B)CaPMW{&Vim;LJ z7Lg*6BcghuePSwN_rycQw}?NG5RkBuXp)#Cu}9KLa*^aesRF4B(l*lnWQt^V$V$l8 z$ZnD|ky|GBN4`M*j)H^28$}nzRZ3h+law`-`;_0PRH)2QRZ^XzCIo~oYG>3PG|V&} zY4T|CXgO$o(XP^-rF~5Mk;ORk1pr0>1ONg60RRF3761SN00CzJ0{{Vd+KrISE(Adog}*jK#>T>OVo@t0=$MX` zC5fMeNCvSU)X>T3qNfF~}#pu>xXluu5zn&DSHyF4lWxQx6v-C51nzmEB!O* zDTZUmIG&L-PpX%-4}?eDsXJD6NFi++(O7OJkLpxX2J1Lg|DSkHp9|KsQjX;GEREyX zyn^yfW?w6d7k_Bo>JOf4m_7Mqs<*XIELV`yD~r=zrl0!BQ2W#_8;#4EQs?%TdZtr` zfpsSTQ<&pGeJ^(XmP#tGbFa~y@}L>HxTXE7WB->r=uE!>4K_{%0001Z+I`VSOp|dK z$MNq|3Wc)wM%=jH_iYQs-Ae0L#JxpX6$CBTt!P|0qcQQOab46naYdsZ)VNpN9z46_ zK|NdY{<-=jPd<5`!;@d~VB!DuJ=}tY2&_aBg^g%puoFuh@g$H)63L{HN*d{8kVzKV z~U?SyAqJqgxVJg#@&J1QUi`mR!F7uer0xHEK5gca=Te-+Ch3yFMcTN+ zRqk?$%iLo-rzMkH+?FiKX1C->uH;F+6xc$I0Znsjrk)PVOudHEp>!!r+ch*zQ|d}X z=}aMQaYXY^QV0BexbDg;|{H89y)fWmjwGTd(!|ye7gf)~7 zrSl)xS({O~0sn=t0gV7lun16Cu>k>&S+Pb2D_9}05LrvG6jE3ruz*<|um&q!SOBmE zAVshPD?|aX1|UVS11m&XuoNqJ+GAi8VBj+P!@$76dE#FH0|Wa!Ad`^+8N37lXYB;| z0001Z+Lcp14#FT5u0m_sy@8WyoScmdlLs))?jFDcIQ9m{*&}!a7>t844xPL}XGeLw z*Mbldg?xFuU)~Q0mFvu`GQ%YdFH}(xtqpAvAnO1+z7uM&5o&lvYUN=2az1&3w)U)@ zoG%D>q1Xv&@1p~s6t5Hd_BZ>m9;m&LCYLqJzNjY;0rC{`xmRldKL%T3zK{dx`d-Yu zc?7*>4fY;j=TlRj7jI^g;ysN07~}i?{XI03(ILRZ;Ni_?q8Oy(t8@%oql^Ld z7EjmDNEhC;uy zQ$1I=i>!zU00i(|9LNAa|GUnz{a^gw{r_J?M3kff0FZ=l7W*4G8n*rnqC&zV-(2-~ zjQb6I5G(+=tRgMLH#hwq%YEaog{M}Mft8*u004^r&8K|h_R*OX(!kmAI|gh1)_DI1 zyieRmV_Op|005lrTT}C`H$tqZEjH0}_-+ev{;h%gAHV=mCYEl--`q0*U^oc?v`azn z1Nlsi^b7$2^Wkp|(>GYYcI50$zsYaz{W~W31`(PdT!X2VqbmSlf&bk{&UgQ{%3N7+ zmNo|8I?L{FZuT4NcUgoSR(h`A{aXJw-ft}c9~2o>#ahqG=$otm*5G{mW1)Q%*R-{9 za0CEsroXwPZ*ITfnfb`p-sron-G5`_`wu!}ZEnv0^J4ey`Tx8i38T3<|Ids4_p?C0 z#|Bnu64|!px@z$E?_WcJ-`*F?I@Am)wT?NT88txt7|IjyU!CFKzuRE?KOm9*>i-4r zW#tI_D%E+bV4hm2LsDz3NY>*27s5BOIgBYz|nOh^h?o2 z#is>>`V;u~+Mux<0qNl=myhVJ0Wh+VBQ?vlS>OsVa1j8+0@&&Q^J47t7ZXwh63G>8 zpWg3<3J%?;9>gCshPYd9XuA74dnSfHrN-|BV~)Cr6GjV$07e1E9!3Jj9Oe~91?C3E z;#VRro#)@ziQ6w;xnfYcA<&#C{AL752oQ)L5SafEB%2Wiw<5m2zJTvvGhcmQq#v}e zS5MJ5S8ZK3cp2`t_dU5#PrJcZT*hO@?r8sbm6^!jwj8q?R zlvdEca@EzfH4e7+c6ZmeH?Yt!Kf*)8LM6o{#K(q5M<~fC$jknfmROjYo1Gn>o?v5O zVWy{~rE02asIM)ru5hw(u(vh0ws^R@yS+WXzCeLPLIei{1&RuZ2oLoS4v-Qt)Vnx7 zNTsp^M|KOxk}K32j2~8=uorFC>y6eHFF0M!H|lJ71?|i=7X3$s1KFp>>M%J>7!&B| z43&JelQqYx?OhZlctSE&pXgdztOjHAS*vsp6rPS@QW5b$`_`@3!Pu>K(f{GbvjKApa22{*(DBqg96gdF4#AP-Og_y=$S z^a83u2ti;0r6BSkN`M7GC7=k91405w1o;if0MrA*0Y`vt5J3phk!Q)($u^nl5Z}Xqrjaf zO8)!wgZ6?FHDjl!o#V!eYns7y-pHcY8?=LQ z2t2j9EFuBRQED)ML1Sa&l{<3>9caTrTIN3)k%<4gyv;{Ak!LIWg0}F`ekjg zY`qu_Y?Nvp3Fo%CC^IXaBpeFTnr!VM%SH$8aP|4E2J5>S&UNv@?bQkQ@(EC?t{n8uO89j)4%6qAt9PD=qT zOb|3nf{>_NNhthLD6S|YR-3Xr^3}P;8fOG%)>?e@@+3Rv%EVZE}aAoO$nxu~A< zG_0>nXX9lvH^g;Uq)3(RE|_TOW*_byKJ*hFMfERGaIp|pXkY7k?D;SQxrhBOV9sNkmHn=La$EdfmfhXzHB7@OEAz4}&dP6K%WGcRKz? zdPZtK2R8O!U<@Pq>~y`u=0?HJCG1jFyw|(*Y)%&5Put8P@G>^-?40WILwg|~<C_|xRAjW@a1U~)7ltIVs zd4P18GJR)#Ej{{ycLE_*OshZHRh2P#$p73(Ok)2twYH`S0o@!v%UFnA<)gPYJokgk~d|sIG>VK4aQ?dq0+F{oEj19!DT98BT-%K#5I!p#8 z*novW7r=PO))9JaB*u-jfKDxkyHK#i$zk2A?n4&Of)+E|YV0L|Js-e4$_bYu{e535 zy&0LYut3&!ZrLP1gG%7I%gMkz&bHrQH4hsIP;^ElQ{K%v$3)smZC9%jtz>t+s3Kb; z%5YQdg_oFCJTvTxW50vQ z5{51fooSL7k~E^U=fpES*k$r=Ke@rXL;1?~V_zS`yUQBu8|#k+Jf}VKe2iZXEQU- ze;J0i=mj{5gSg!20kXKoKSBJUSd((Hop=(* zg+>8#5}|XXSn4Sz#FI76LK^(&GGhGZ#JnuZe%_kt)AP;tGxlU!BRsM z$U_VOR?cHb2gL5A8*r=zDLgc3PwTErFOyBlPL8p(l`BoJnpD%PW0G6FOz`1gBr76_ov=zNwVsykr;*w>QA z*nCtK;7E<}WR`pGG@#XC{X`FTVQa3ITUb55{2+S>c9D$S%kJFXH-_MC~UJzT|x2S zn^Dm{bvwrr(JfzpBrJ0CZDLC7pBPIl^Btow{xl^CWd)xNGS!Oy`v^#3^u!6tbR`S` zZGS2u-je2S_1p@RwkWC6nk>t1I`C?b8tVqO3U*bN&Q&RbG5_?&bKx%U$cxH-1TZbN|AohjWFX?@`C(j0~$y!mx01ZoWz6=EDs&$tmN#a#atago-N2iH|c%? z)AAd`+<6Q85m3Zh=!!&(`po$&_%rNhfNoAoj1W5j&dz<^se1_%@Z){z0R9;)Xw{Y5 zY_&DMxd~`BXl`b6Rnw)};4xw??xpJOe@-f|PvYD8!fZ{Co!Vf19rpT`?vVukcJHAB zsYASO{Lo$<-5K0}Q2vaI=88yDh;+dXcl4|H5%-_sb+oLbG~iDHGN^a7;!yZCL3*K= zg^Z`(0`7BNKZP!du9rkd>%$29=}YHu`NNg=pGxd0njgkHHl=U#OA9XZOLah$hum^} z$>$XU#8zE^$H>S_GsWb9ygji!TcHx;wb8as35*Z-PU8GrvR(@D^IH=1#kPeGy zt5Q`0xnmorNwkiXWQTTXfkU%pDy~>&1&SYwo}SL{or>~Ok};AHGcm#5yF;4CNUu4R zCO}OaBgZ+ywf_vQz48sW3Pnii zAz#_;my+u|62yWRgG|;52TL&5S`JOh-Ja~->z-j%>veOh4;Snie%bs-Yl|U`$&oqR zN>(qiT>2t^$!x)qR5gAvq{?5szmx!q965qA3Y?7vy)9m8QU}HnH;1mO%PT9Jw(N0b z-7Y2@n%-lQDs-9aVxPl4XhL|dRYW4s$n_m3c-FnvBdqO%s6NgI{~DjGf;|#56;{sy znA?)`j9Yj{SPH&ZxjBB(sRmsM>S1qJ*5|HPJhLZ%gHyMT*xPMgdv={1je=ny2St;d zuIcU8gg44A*~e2CQ3xSFiA*Xs09$Ag{u-uuj_K-|W_y!KMvza`g8 zrr}laVGYFVQ6`!rp_5anlTy(WjmUQe$(Kb~w1}k=CEpY#u(SD|DGFNKY80Wr4R{5A zOsuIT*j=<4=QbdDUHH=To$P!ZWzi?LSkmV9e%akSZ9}Z2)FQ59>A2kpt}4}CzVBsa8$IIerd=V> z0jD`Tv?uX&0J~;?CVaki>nUI*nIqA)%co39om&@P@Yws=yp4=kf5i>n=C%ff6I|z_K^J&e zRahcB;={-4acm00d8Sb&R|m@2fxPzuc+u6Q*maHmp)QCSLHmen7?n{Lqj>)Fh_DvE z^2B6|iGO`>A5iSHy9&gMiKMoAs@SqM zN60qgs5=-*zrx{)VdHN#`6sGMqs?qFA~@ys#^Ik0*L<|oG34txOpN4hx}T)p+=4{Y z9j+q|ZRF4T7xcnRI-onM=8qMTXllnc4!K>VBlwEDjn5m<6#EE1qY9IHRl8ez;7E6 zYL4DQf2`y`?&x1>(4XXfc>XJL`J4e$POFGt-r0v8c)kkhzOe}Xi*zj`Y=-_Ho0f>7 zMKTyJ1IL{oGPud6kEknwO;gJ>SYLjWVhHSo6>M{dUyo@WXGY~(vp7*$RxHSPm=u#D z`U97CnFT%#``UE!`XBg-a>B=i)?iC@ap#VIYpxDwQ(L3PTd(ZAp)&((eCQ7RKxNS2 z13xV7{c{W%Tlrp^W@>&;s;x*Sq}D`87;kP?1VhEdL08_kqG{$eY$KO^%iur`-<$Pq z5_aDk%WhYeYZeKF_E4xnBx?Rq4E>nZAGHI8NWe4bURx0ZNJMia2`DY5$H#sD*Ty#7 zbau%JNZtlPbQ`SId2fTVa%;JTNNWZ=7wxIMs-GRPz&Ec4VeiLX#i}xh{wIs-P3vuc z3Ytl)MHL)hR9KD)$7w=I3^K`IT2A~uA|UjT#P1jszx(*^^oj{U8s4_&j}qXYQ3=7q z=nElq5+GgqV89mIaE5nigsZz{vo%?IB+dvd3u%(i`Q%TDE=?Jog1Wh;u}Sjiacvnm zJ7ntS3NgO0=sSg1mwuAKR0-B5r=oUfHuacO&hcNQ8yj*+%mz=_P8pT>GliSx(G@ZxQV7QQ3zl>L6@39Qr4rwUrE60Rw1 zO!?2CIf#Ku|1x;NXd9VM_thk}1)G6@xB?>11{u?bVXHifiY`q=V*XN@|)Y_afMg}E#pz@QrIn-97!}$5Wci~VaR5ml$&Ge zqs_%8YkuoVdYdjUb5$ml&D&`0efg&#knQD#nP_G8F?FEM#7Z6bzVK4_WOHeqE|dqA zmF5EU=o{jFAz+hvlJ>CNXpPEBjYsEk-A(OqXp5d|qhxd#>}9vWO?-jkY%}3$vLZ~K zg}i?+hs>t1hI@LFBHSQY;f5~ZxXz-Aje$B|0i~gtbr6(rrgJBGt{+^)vVsCg8OY~x z`Y1S6*e@4`f1r5seK3k-UNTn4+{ECOG({-us z)Tkk+yKs@bWHa0;mSlC{YM$OfEmdUKK0&yfsDf7Y%MGiF3i>=Ow*>=l;f#Jhm>^=b z;!5|7N|;95-;_LrhT5JSjW8LbIDk^%CJdzNn2v%xB*;D&ZZIn_0j@J2k1#t|1rHcH zu9z*T8L`^(yy-kSkqM#+w>6tc!?vv1n%?u6*y1?y{xGfTT=Ta~)#IRVNu?V9XM5cW z{AvGzQikBSct&h4;keCL6qlhN>SOyJ%1R{h+44= zBajOt8bqDysLB$@B5`s=`jn6zW<4)`vE5>p+p!nns*;XV1B|l`(OG?=rr=pk=~Q$O zV-Nm$oKS^*jNd;%za9r5XuRuSqlvuU*;b&eA2Ro zYd0@X3#`xA9r3(%wt+y6x1twVSI!lY!MNtv%?x3|w>qNC<%gP)0FP|T$CkH|x2u0c zGTg1T9WnTJaq8l@m)tchd@S5O@7MU(A8yrcINPCkyY>kCw1QY2FMd@X!4Qj znF!rDWRL?e92=mmW9b5(e>61ky6*W$&aT;n)55M1_2tx$@Xqm4JPkI6`JylYneSE5u z{c6bHHR5#W)fK#ENwPVd4vbHDYI6do!gjEeyB}OB$6T(tP1hEDGt9u)o}0}peLa#! z_~6#b+wpwx3CLlu#h0enwL${ek@@5^MI17R4HWH+cD$QWCIBb zj$UHaJiF49AnqksFRjvecbW$=PXX;_(>FgaSdDBI#L_M|>&MuxEYbOFR`Jl{WUBO) znYB1n6+_YnE9&x0Ze}@dT9?-kOVOdlu@$#F)_d>{aHoF$?K`mUBmPSe8uV^gf6aZ3 z0HG1RKlVoS%M_g5ec+D^I59|SHX_xVw|)b^`GV-1?MbSl)2uH6R8zrODp8EC^x%J* znR#ZpkP#n*v~(iP%$xm%T(j>ldDj-u(_UJ1FE<&l&$E`|j;8+El<@BK88V8;*aojk zH=C($$s=~zn%}&z8*=48ag@qVPeI#2OYw=N0();CG#84Cu_xBzC&EXYN$R(WNT=E}^a97cKSjj7f7u=|5$f^ZW@d=lP55Gr^K7iI&Wl zw{I0*D%+hfXoI>+wWG^Y#mr`Z&0oJ>sa+=dr!vdi}ZXd}nMjlRy1AT$7*Q(7>HIafL8{HmCVH{{ zoC)1hj+-S#V$_-YCc)xSCz_d!Rn*|}7hZY2tM)nST$(ab%;K^;)2u?GAavVLyr76O z4tuP519v&GZ=dCI0_a_Bip8$?fG?tjy3Iq_qYU?m_w_IU*P-qEM{3}JX%zKZ2r0{! zGm$R_Z9av<_x_fj>y&LJP)8sZW+ek1FY9^gg zUf8HM>~Uk3YdY29j3csje&p5 zN*K;v{y2@yKSlp~Lx2o`+1OY)kCbc;XEj5JDyH9A$pK#A)05b-V+#P#rc`i+GO=k` zL&5%;_T=;%w*PeWkq&FTnr>VAy zy-(jHDo|-Pw|k|%5$fc*%WAnh)xDzq5uK+rJUGptnjisjs&zM9zTALxwRh07 z_9w~A%x@6FpdxG=icE_AeaQ|`T_A7S#c?ttD6Aa~4)eq;@;m`ILo=p{oJ)0K>%))W zauqro+PM!1ZjnQ-e$`KS+hsb=?@rjJR@@@i$p*|lA6G?-zo(T&Q+=F}KlCT46X9;i zyV%YU#F@Pfjf8}r{N7Tj0;;O08ofv&((p7l^Gq(b=x)f|$oE9<7&}m9QuSznl9xy4 z*%^0>AXR@avX#at3@q8P99tZ8y6O^BS=Ej(VWx%Zs9LNi7&z$@pmmZr0l14|o;{Ht z7jtNt_;WgLhA*|1k#+91EyU>vRraM$#N*l;G!PWSp>yauD=^KPZI?mrD$3Cn>6;v5 zua-7Xocn5+2w(PhMZbx0AWJUr`c8@NyA55is5t{&B5ZZ_hm92^5V9##9<+X&uC8hp znn&nQL79frYv1qrCx0ewI_9HCo3nxb9MXvsMxz?Lf7SQdg86SLNj0f3GkS1=YXgBI z+3n&CHB6){Y)Q05ZY(9lu6+;$q>uHL2r13^Nu991R9Xg$9y8R|DcvmFKcD@t_@_f% zT!-0MFD^sjNo-pz(WUikWv)xz`_Bf#GFYzm_jE~5zLR+oP#)=7jD>}r42Q{J zq_SCtQR}3p9gForAz!+o;DWG{khC2thYVsn7=CBclv#61`ZKA$Y?sXSF+U~eVoOXp zeP;h!CIH^83g>DB%eQYeNG=P?C$4`~9#RyLC8NCbeM1wqc+51yQuU1#{3v(ndo(RS zCvw3VgG;s86_9O=UOKvmBb+5v5%CLS$u!QPAKkmL|7d)YVVz|rKAgK7PL!{VWri-S zX=wg9QF1^xzJEd6>dG;|I?-&(CvW+HXo#7Jc`!k9bf(I@L2oRr6s|MowapUCJS~E? zDlk}Wubldt*nM1li}F0fsDs*sXyukMkkU0kCV`_xJ!``3(MV61{J|Sg^5b|ZR2ded ze*iX5k>0;cU*E@hLt;YZFdF+GW=?9&I5=MuY?%rr)lJn#VrM8h3^ky02>MCzrZimd+TwDkb`^AW8IJnw+KP@XB^FsB%OiI?_CAcROUNB8kp>7Mp!f#sy`dr(1^Q> zmH z56F&+;*ndM(#_pm&kf+nyISzVS}1f z!SDrDJe0n__nc0u^2yH@ZOin1I=N)nZ{1&QA|N0_U`HFX|y1434lN}s`8(u zeii>dw&63AaC@2#Gs1X999)Q4mVqt@HtZ@SMt%=iP~Zck@Q<0=zf9_08v5Pi$kh(zEKNhatKdW_$aOih z)GP05!CF>A)ynB}Pe7Y%cI0T+E@~hQ1cqDIs94#?M@l3SeyLdl}s_k*)FR)3^OcBAZsW8ghm% zVK{c2r^RjBtXs6@Tj9IfL4oYaOR3tZ#ATXfZfZ?x8&o(I@uT9g14T|byX7-9_Ae%5 z#5{j0G^7I{e!8i+%YB@u!&(HHC?#p6D$SERYY%5VXm(&?9}v z2YeOndWUN>GgFc>Ce%VfEw+=hYm2xxqJiSe#ivi?v*+aWAfn@&?)>cm-0{dxd=9Dq zizx0TL!ha@VLs7&=A?d0@kLbbPP2lTcc`a4+MAZ#m*!C->n2xMJ5g<{=rCz1*fmz( z68{S{s6HX=Dh97T$n>qX= zX(~sL8JSW{w+fdPkkYh^SRTPJdw{Y@H+xl(CW@raftBl1nM`VqF9tPc;bgH8W%#9g zs#Dt5lG?uDSpAlB4KPi^d*A7Ha$*@>2yxdrpC@GldqOX#!E%B{n-4RssUD~Ko`aPi zR`R#dO1B|)8l;lDIgsoGA$>a4KQ{lse2E2=A3DTw=yFRximRojcH~~=zed)V90gv~ zqty$ZiR{h}#3{Xdh+cZsH6=icDEu*iluxyTDXO#)*NbOzRk8XS1>T@~?Q-ne6TW}) zv{rWQ+UN0E5FF1sPE>OU;pHB;U0?-=lkF+Bp6)6wB%hM1mtvo}4~vAJ6H1?YhEA2F zFWhDRA6XIN`*5P&Z z@BQ$H{XRBPY+5Lfu^C>?;Tm!9Q^P^7^al$7c3`i!q3)GreI@iD6a}QG}?2wU28u%boP@!tB}RTmpp=qn5qC0#aaCeMfOR}L-mW=UKCk9SnN?g}%b2MO=y%H}JJiW&^`15*Oy8M@6*uv_X6ms!G&pvsl$Dfyr>Hq#xe8wg!%bogDoJqm@q-|ehkzignMK{ z>O>4M4iGT-OpyEpExV@tvc0A=dwqp1C(R80#I=WY*)jXQuwH|@ahp~KtuS_9>P#w#!$kUxAbQGwfoacuY7znD-|$y z)mzJ!L~$P>h6-8~9FFESY3h*4PrHEI?3l`BduVI2xH;!xE=_x~DjpH~L<^URKNUM4 zE~+tqQ5=WOnyE@l&BhzQxP2M$vj5(;8xkDhf*D_ z#>$y=p5)*2+V^nxU(t7ggZjd-H)}&3`s;6|gmof-Eo74ukbTonUheGO!DmdXwz!E+ z{5C)KBzbyzDo9&O8^0e#d-1MidN>3!SCFpumD%iXsPQ=XdcNr&z(sB{BAx$q)}{t` z&LH=fRkcUBWq|5T#nwDkFDvm5-A@HC$!9u5t(*%sF!3Wre}JQlLQT7eg3XJ6-#VYt z#Lk0kGqV{DQKf`3qs<9p%iDj6KabdPssBveQ6I8IrR!_nOaW-WV!zAc{~=K{8er4x zb^vx6N^SV3#gu4E^JN6n5UPaJ%l#$}Z&HhCD`kY(x#tnSEca519N_${R684d8o^KG9@=$Yw>GH0AH&8{iRmR z1((AEW*XE2C1gB1+o;Ah3SzQ}0;prU8Y0BNf@F07eSoaK1v^j)S~%2y$RjbCSu`Q_f0o}@nIbn3rMm)%_NV$D3@0#T&1S(ufhjH~k>P$9<219QLQ`qZv}ayaiSWO( zBQL~)F8Xb~V8D`SlQ>s-%J~ zA1=HWuqd1L<0g8AS-pyJDAtrOs@I#h@l^cY=uI!1nsyb>{G&rv+Yry9&<9FVJ{Dkf zkD_L)`78akp5yFXMqt;Z2pIH!=KnD}sm&|PGEVB@9NVZR<8>!@Wj=e;dn-FWPSonm z^BTY4K-y4odg^7h=0BH~Y@=~~Prr)@IVEH)%Uf?2Uvp6f%+PKqHQHr_O`BC@q&dU+ zyl=d`Y~X~U`lM-xzom#sOt0sd9C>YVYYRRk7fDfNN7*eDP-I^qUzzel8Cbr&Thb80 zQqQd!AI9QTqv!w?U7+#swY)Ge`^dlnypdUXa;kZg!{jKa(be7I zIN)1&R#~AhKUlCdu<5k_r zOmwoDnM{n>bPmspome|kuyD>?CEC}*ZN~iv$a6K?);!mNAXUeNV4LK;JT6$SFo-ry zqFVdlSD}b4uNW>gMf9fFphl`M_s7HA^5MOEfL6GCCaqR*gDc&hEc znnPpW&f(&FP}nWFW%az-5KO(N2I!(qPONUM+a!;x%d`SZTlT}6TevEyD+GA_NR;1* zVdF|oaihX9@-q3E5(yhH%Gt(H~TlJb(v0| zc$E2#{j=m^+O!VUrL>MzIp9}egU}Z*22ohcKL|iLzDwGOMMM-79mi#RA_^6j*7inf z4h`k4I(OU;&`16X&9bf?UYVzvbgBq2sck4ec8MKMSQsloKG{GPdoUbP2mhHJ+C9kp zkxL9n^%7m~VYuHuNmUVuvj;WcnMq|GpMdM`9g^7%${W9W!QXOtG4qh(*49_KmbMNI zW&oF0YG#NCI%%)iML4*-?s9on4AnV!Gp4A~vF5vM&-PETMZOOdnxfqQa>7)pSXZx?{{f1%nA%UX|O0 z(hCx$`xuotFV-Ugi`vP6+=n}hEt8&b4L&t)d?_p_7lU7V9p^H{>m>rr5nFeN!{Xh4 z6?8Kwo19W0tMP`mnOz?`^>UAAq?|GXqzCS)Fw#35 zoD&L8A0H}-xVkL7Y;3KX3bM4&tAjP&Svy)MElB^c@%!3eA6V&RZw_>|^VB(;N+#*H z**7-ryiaqnrRtyr$LD3`@(>)Sh74*hBTR96{WJO3TV)tjyLgymhcyY`gOdk;FXgyD z9IBTQXp?UuhxS6h$dpuzk)({>JFKp(7v^Wn4pSOahx1v=Flo=`^;vpNcD%~huupXj zk3~~e(8!Nz$>=iAB+Ek<8##l@cx3JUhNcZh=V@%GeXC;B=kV6e(g?Objh8WaP_9uQ zg*k{iY^*$wWjw);QIfw%_h|Oolb~1*+G!f-v7BV$T;)*k;EQ(EiHAp;t7x$llZ~TF zi>6{jda{nrvqlLtx*@1d76RIvKa^&dqRVEs+C1= z)um+ezX7~3@4f7Gtl8SdB7;xY_Sn+m%2KG2DGx&Na6%29sxcOS}j0@h&X*7^pe=hy<(iB|Hp>(i8q1x&q zcE1*z>5{IjKr&KSAmxhlGF~3>YKXpqn%ry$Ul8Ox(F z6KVa1$Kjv8j~RR5Yr)TpmKT}2BxC9hRaVeCn_{U2le|Je76DB;jR6ZVxDK{DkUx35 z`(zTK-Eb{_hrI^$PsWxXE6_VO~k5TiwMl7QTQ z{pk}J{q{M$Dk;IXjjXaEz-EN|i@FiVIVo%)iL{EFF)o73$gtmfb`#cLRJM$!#Pm7= z1+M6} z0_}0OB#0|l1qfEKkfa{qSyi-B^>Y5ekD@e%R2=XN2)tY4@DeGrTnY*cTHo|~w^2jm zB3AOuniXX-G-2Sc4Lrn0Ur@2U@xOO%zjj5whN;_v>PD7z)y7PMdiMLcYJEAxhDe`I zmZ~ndI>o(`&sW)9p94qKKh{x6oiE&iEw^qKqvs4yCoy$1<4sef(Rgaxr9Vcpf~+nk zPFAK4R4Vfv9Z?L6bfo+qHHRGU2@CX;$1UOw-fz1H6?HcwSn6Q2=WONH`q*2wBT^TO4UK%2ve4cnRRCu`^ zncIghJm{c-^%_oNb^U!XStbuvfVktXrIk*EzKzRsDOB(5+tgAbIgszqb5j~;J(Ewz zf|Q%(89&FC8S;MQLsdi`{P|+T#D;+MI0+5_|yL@)LRTH}sx7rr1Eh zjwXM3fy9!+yiw{8jl}96O)3oI9di6!|E!@TpHA&7Vnpu8%wX2}*o`d@F$ItO@Gs-b zq9)imv|Fo{+|9yRVfD_RAGsZOL!=GsT*EoVX0&^}2?u#@N#Tq6yA8``XiZe8A2wGN z9mJ^GV+u13{vRl^pKELR3Nw*?CC7t^lENM$MS0Qv&qC*+!NW-p^0l(=w#R<2W7@43 z>eq@d73yk1)^Eei(^x>>3bMPxx%v1$Wi|RX6FW##XT)}P#7yB`+{eRJpu?TTz)#}{ zoVOir11fu*knd#7>;2hOA{^C~Po6A10ss2Pv<*;u{B9;suy~hA&wIKgMcQABA3S=Y zOubeGgjanTxCTh3pZkM5ih$_B2(2=qZXnX`5j=OWoIX##!YJOC{o6a^SMJM^UAT_7fe-~# zh}%<`?`L+i_k##Ms)iH~l-eyj-Ey|;!NJ?f5|vu%*lkV3HMAgiW~zpfiPcX5)=s&TQO0#xesdZ#^0I-7sB@nZ`W4~=omFj3$|U_i1qnL3*y zXYCI#K1B{Au+E&@(yyeGdX@-vrtBz}qn%2x$DM2-9|8YWMn6qVTg3*g4sQmXj~l#y zaY*1!APhv8ovBYIDo%xKZ%0QDr4gi~=_XkyN|aj$D51co?-m4$zy$?u6YVEhTxTGB zNb23fo4{}XTy0PGNXd<{9o>UWFps(10inUGl!-7vaobUyXTG%jKmfjT5Y{V z8G-!VJn{Od7&%_BE_r$-9J_2S-a+MwwGs!ew6)#tnxGrbjTlMlwgcsd?rmtEhYA@_ z51$(9?gO(v2jW0l)lOYcBq ztpsLMg5XK7j*n+|+~}83Ow;peZ&GvzZ}em+DRAUJhY*<-Qb9T6sr(=X;K`$Fb(=9K zDrGQON_E>IL0>-yfa{adfnxgL==ubedK9*h4zj!}>hh*0M8s`5i7pXBlAu)0;7 z$%X3F%ie;t#DZ;QWv%64WK)>4(c7K2j;a#oNDC!Ub|ae>k;y1LuL$$e@)? zaX=`Xx_|awYw!4^MKX+$OlZ+nk1k;)(6JJ%!f$2|kuK?$WCj|IK#Q7EK3<%V9ElE1 zs_)P@c21zzJ<8aIuQotzwby|4HKp(h!o_hBs}!g=_%FJg z$U0j#`3{e{zo2lx-V#jtv$oM!GBo@Vf6H>>+GQzh@=vu}8*HBC|B0-ng}9b{f#zQP zUqS@#6nc=wFqavstC9_}n+oF`A$bj(%;t$y@xs(^2K%pHWEyx5`=>Dn9<`8B6C+~{ z4I|h7uVUQUAH{YVcBjRPGNCuS*1bb-yK9|`GsQL%o(5lw{g+j&hS-bFTKJhIe~pJ` zCj;NP7@qpkPL}l?)Dm5SA_Oy--FPfLUn00y1&u2^nrOzqSX%Yb6LZVxarrz@fQ(#a z2;x+uvR+I*^dxoH2u}R9oK2%=YqaY_I z!sTTwJ2k*CPiiqiG2?eKefLqkTRs0@xONGGcpciIcn;TcsmWTQ;tsavLUpob&8QC~ zbyK{hyNkZD?5Y^>T8PH@zf)2ni$o`6(_egd%(D6D{d^c}TWr-7L7KOH(8D6pPuKWmv}cn#=71ww{BJJo7|msx2sZV@EL1Xj@3{d7SnsE9Uxb)?XH&(H8pq!*6-)* z)t1#D|b#kPW8ypJ~nOYAC$Hs<)f74};D3 z71jD#1g#0+cNWFv5;jsQ9Z| z{Fw@t5R*d3y7FE1A{ zxx>G#clMoc`4A6?QC&~+T>ZlB($xad8mWhwC)i0PconfEr|%%cH~is4aY~&1T1#^n z`^!M464{p1b-++bYAtkD2^8QcBYA<=x-|j=l9WnZDBZ(Qr`6JA6B2i>q8v?_6*evF ze$lgE|1W1Un9WgVC8LH&L%sUT%9HO`#K`+n?^&{9tweexzdHZruzI0^G*qhRrPrjP zP~EFh(zWU2CUO;gmR52cj!yWvKbzf8`+CZ3KLbu@(6brocbK14vi|hU`V*P;H%fbb z_$Vcyta8Z=G8rD!Wb*SIoq|{F)EG5$iPk)N(mGITI&xyiu_wb{Kej_X&%Ztt5?1h+ zhQi3pi`5s!2*}1p?rt)hD>b5MqqB5iyu{3DKJfNh(32qtazjWV^e?-Y-l2dLS zP@>p8M8~gKtT@9X?aWU|w*c_qSSD8CCd-PMEzwwdLQCtUGDUWqiA?24F0bGB+>O0w@6PgzyBB|X@0u->T2HM}3+leF zrRrw%`4^Er`vXfq;K<~sTD#k4c6YA&pZibEUf;KBbyEH3uSUA3-ZS&=X&;}_BOmWs z*Y{i9k(P!?UAKAV$LG%OGCzhi&4)x@cul-WY5H@l5>=b~Uq$Esvz-*!M@s1|Z|^Rf z>FQ>)4@K6>kDv6~+i591G)&RB>O@Qr2Eb;svXRv#N(FQtrCyaO5 z$ep@ox68?4R?Op!HfP{NU5pD*%tyc%(kcUS+z$9h=%*gMaDg-&e_frSo<8vKSDqkE zC!cv)J#|stzi{*BmliH^#Jk*+C$0L_oC7@%2K~KrH_e<$u9Bz8c<>n2D<5#`;-Nh& zpCn_{nJ*JB*#LI#(C@Fm{y&}z3CHFKH*NghNs?Y;Om=^o%CBzzlxPLm)^KAm`r_5G zs5bf%bZ99?Vj`%}v0D*~Lh(*Lo#QoDn~%o^B}EwIP}GUdIIaV8;k1DfgRCxhq?Hal z%{!~Y^#~w8^Xh{*_d}DHZe`zvSaDe zHz&`TPiu@{;CjS_?iC1Zsxr!)w8)QA0dafsb|zPUnM^* zo}s_V9TVQ>Pr>&;#mORwJ?6EEJi3-*F#(`Y6^pmEtp;ch3Ex;88jY-Cr6mjHHSr#t z!r^%_E|?xXK8@EOAG%KN`OnX27Dn*VI4(`1cjlyE2zf`T9h*)g(vf51&4q>}<){XB zVN7$Ox(YAIX*&3fa@mAYT-G$qS8-(j`rGkXiw2wS|NZwAHlap2-H7hd*a?GJZC5p6 zu>VId{%#Eu{E}0|Irg>wK{!>$z>l%ce8bo@n9@l+>Nr_K`5mf~YR5E;O{PcmJ;d#l zmxJMI9BQdV>w)g-aBh7_8zQ1q;U)nFZ|jG#ucz1_>NR-imK#8x9+2!466B8DyVzH; zzQRkKIg(vi;oi2qDO2lC>${eJuJ(_z@6apv^P7A2{r3md!}pWr>bv)o@2@M+_*{c{ zLLb&|WwrU7j`=be+~9O0YV)!Cj5J_zzIfv3QEI#J9lCdgz4{K$4xTIMdI2l+1B}Bh zDXfd8)$<{WQRebsMKq2=W8-&djjRtVqAh}p=1>CIIc}t#<79$1*wU*nZkLdm7^ejR ze8(dzwk+wG{_mSVJ9W-etJ^1ZkX18VGQy?J4=wAMzG(A>%*UQsotX5=)h!vyqib+( zgMd3BIJiB-9vhn|s9164FdHkV=uN{D4{X4Db}X-=oM?bgM%uhtYSMh^+5<()(nu{! zo0Y{Ati!d>nBO+paEyf&k9eIHLF>MU6;f84-Em8$98NPVO>$oo*S!+Ixj#;}bRPXU z*%DV*bsp|qc4=|3U;4tB`@!p(O}JV^ijBM;ZF&d04}v?T?ch+ju67d z9i-!taIS@v(po)oqC}C+W7Abi(_=)g8#R#`2Mk4+x#>ii6k?F9*Jg9)tp0#j-*2O% zz+@+?C@}1pjzXV0(kk2VA}imOgRG+&jF^Bw(9Fi0Wzsb*6AWbAR+VF}OqOKTSHwwf(DCo!-Y^?MvCoeQj<#+3~p!5^68B5@pBq^rOo= zrs2FZeg)WPdq(utaHIQbjHSLB6N$n%h?9iXbs~>-cGPccS67JHNJ%gA+@r@)!sG`ei1fw^FML{VZX99L}d3bwEoua?15Di>Qw9gWyM>Kr?WBE&j& zu=q{d(kKRzMCphsx}OprS*s&xbzZKg^ELMlpih6>W z1s{>q1<|ByCnDBRt#>bd>^n;_yZgNdF{PVZ)85<#P^!uf^)75EWpuN3>U`FVCWghc zoR|ANmow3RaWk8JK9Sbvj_7YJhV(Fz>ljd6=0VvxQ0fxLE?aPCz#lZ@7;wt~SHN|+ zv;Y8>S5NOH(O_g-|FTjGs{ADrLg78txe|@&uLrDpzc>}qLxU|xr!CI3bC++4rL-t z8yK|G4btXmpSbaP@1D&)CrDTKBVFq9d3G{=#tSQgkItZK0{;FPkfAsS(8T=>o3J69 zQaGl3BAs$PqHwg>^)*~L8rF(4!?)Y|K*3rrx4U;$4U5@bQ zcar|pj{Aq!?F5^8E!foPLz{uSW^&A~()234kVBJ7bR;46YNO?BapItS^p%3zR6>tM zD**~P&@j;#b!w)@<>jOrPg!IKTt~8Y_ntS&TJ`Af)y>yaO`Sb67N$}&R(w-1zPx!0 zQ4gI~-yt8Loo<@7_-nJ$O^4Y`l3uPyxLUM*Genm$kve+pC5c>?^bEa4z6dXsB@Ya} z`3^~vOibg(J6(tV&zzzYGiDRJ5km>+K3+l|gSAv|z~*~jT|ev3a% ztJte?T7nm}wa-kGFjf=enu<|7L6z<7q~&LtxBTLVh`atNKe#qqD}bOAicHlwbG1M9 ziGR7s*vi_7+@u6DgQDykz~M|^DT*T-6-Vy71{GfbTW6KPU37F+-tM+xf*g-*axSfH z!=sM&wOcghIMsm$0J0_yI2u)LpqZLPhvg+^2dkJJvC9-tkQ5>rLN{##A26QwOcxGr z`$K1E6qt z0ytQt;h>((8{UVjzBuuA7!B?qq5+lY*bz#U$njB-2jNxlu}?lH)})}GM7uxalzBQi zeN?PR88aF|#ftSJf~*ulkuyKhEP0z#wht(=R!jirt7ABzCqj=k^ccls4vx2EBC1=t zsTMkMI9wf#jmR>9CeYvh4zptX3@H{mh{UA?YMFkQFs-cA)zi6xb!gH$aU&9p>Cl0@ zBT?re+PLDPes9L)rk#KT57tgZIJor>olC;xp*_b|5l>C`hVZ%>(XpY`fWTJ|+x0;q z+TB2=Mn_=v#`)~}E_c^wW|E5TLv7@x=N20U2k*{I-^(GNbpeidQykZGP22>shIKgs zpQVt`LL~%ynKM_mK}o!s!wpIjxW8hYab9B+a9(p9A8Bp?&KuiYFxBBxXa!&pRzPVl zg2(T$(aR2P#(K*rBC!m+cNi{^+z5GT9Rec) zT}CT5q^a$elEI7qVA0GQ!Q5TK!LR<|V~OZWV^e(Xu0$yH;>_ed##NE8KJ*GXy?$Qz z<6R^?g5@)mICQ>mC)~YVo7PRPOg@z%`*zPrJ-qZ2on+|s5h4I&`8;*D&;j;b6<33k z;cy01t{M}oku*lYT(naGJqRy)5YbYRZ){`^ORm=XMA6;?EqFGUW5MZy#6^IYnxI*CyDDLGp2vJv+(NTRd@Gws22~Y62GR2#8Z0@ ztj$cAcW?XO&8~a8yK7Nq^A~rLq^!O$jR@D@dk?sY&Y3oBq;sYN+)IDbq-i;jDlZ)P zFFI@*Cwks-;PeV?xF0!nntx4wiKB5>tYvHX&%(z0{|nfFb96`8gh8N3)O91FL-vq+ z%HgBe;1lA0^ryl{4y4OV|NiTO$Roui!yUo&GWeE}ZF`^Me|IlSMtr#F-F>mB1<1O>b)gZR4so5e82eAsh={VW4u!yJD^nFH7G|0N>CO5 zGhpriMa`-IO?_Be+#bOeAbJebV>KR8K_$kcz8Xi5NqTI=V-CJDqEiUt3DvDRxQU;W z*uNzwz|yh1J(Z!V$k@cVWaId7^+-dL;NHQ*NWJrex2@&81>3BaiLWMsvT`OprYP=A z08+B^(e}G)EP5lKj@}d68BTYu=xC0bjiSJ}gr`-Fri*RUmytxs2<~Wd)23N)UTHK4 zJfGYQb`H`>)F5dxCq%~GmQuV(DHUm)fPg8f;D?b&RdIf}o6QfWnM^PH=%t$uvl}!a zRLMS7I^~eIH?f=TP0VcH|0=x7MqV3DxO;678^sO9sfD*PLvaaVg9s)2P6B9Az&XY2gPNk+n|D z8DUWfT8&NrMW9{lWt%vSbtx4!=pl@&2cUbawD!kaVP1-T8?@kepwta_M?B1!J8#+S z)|T$>l{3=!Jo-SUA+xA0IervYUR(M%-4oMY%Rk+n$gJogQfgXHGKKaZ&OLj9&fpA@ zF0Ja=)`*K6dGm5^6#WH9p%Q=5BPh!Qsf4o5t92hdT$L#^_Wk9dP&kcQ-QOYp0mQ zjqpM=dT0n?$46dt2`uLRp|N;;(n+5Lta{v)to+UE3(`3W&pT_3TAygl2w|*Z{-iQ{~)sC{$EM2el{EZe#g+}Ij^nk zmcAyh!CgJn7k8@FeQIK_x}WSS?(TtjJE+dq_O2Mm?bCLzkQft{w%bdjN=fWw`D~g9 za7vs>sQ8FUHMq;9gVUn*a>SL7Np*A!x41j!Mvr%RuRVjiwBJP-D|;)^4$p_8u{z9- zStRg;IRg!X3$8!1`2`KzWk!VUZo41GE2nWk48nWb(;G?NyJu6+Nz&c@$fxeOL&nge zVyy3x8JW!R+~9R!PXN7hKmW7tH~~&lnbP>sO((*CrcEaldu8iK*>(a=u@BjLV(2Ou zV%b|apfGGii}n91%qsprfLZV(!3^^s9|AMrM;ECAEB_X#={uOEUk~y1{dQ%(R0Wls0|Mg=%`Ch>l1zU_>iZMH;XE6VOx1 zkit-uH+w(_0eUJadMa;+9!#t%E@vx_OU_#zHZMwHWB8-)OH-_(`Y==}VC%h_crAH5 zL=|m5p6%TMG;aZ`ulqxG?~om-5lQv`~n*_H1!04<^O_q<6FaS>6pL z$gS_TAKhLiH}LI>(qiQMc`y_8Vecn9(s$T*;7@%;%A&Wt=Ft0?`Q85P*BN6DziH7g zXYVReSbA_$K>6ER1v`)oP6DEIC1eYRY<1&FpkxnjT_2SkCR zlhdNb$!XQNlc? z67)EZ9+P;?!DA!hFgduXMPL%(^tEzRtp;ahsH(bQY-0S#={RJncX%I<+duLV_V&;^ z$asG#=pw~Zd?QKmXk*`T=a2iPah)qC-xaeM^)&7xC8w{%xC?L6=~&=p^wuEy4lVX# z6q1{E-m^4OY2*z&4ZUdlNY4g3u+uEUU*2Zd5KyJX|0MaMZFdn2&6n*06vaM_;-EPTkr6tFkwIw%<8~>**na*7r#h0X>&ZYS!|VT4kY*5RV6 zj+KLF1VvP{;x|;w5!Rz!%-Dugg_`1xA{6B)KES%N@-aiem?%h0k0V9Z;GVv&RwWwI zdbB?>U^U(SVL;qMKMK5x`kjDAUnAOu8DP)cyD{bM5QB@>6c%XBKYI`>a4PU9;O$DhQToFFTi(^cwsl?ScOS{ee~JGT zMN$++krYKsj73Ydtk4o<&2tRbaRq^MyiD^{S+k{jn&KLQW(c043aS$rikrf7(zG*- zA_)vt<&TiKhMO30J5^0Q&kJ1F(2~_Px-3bTZK-G2S@gVn&V7%1vgBAPur9y^h@sPD%=anfq8lfIEgd^S?z1YSW;H*jXbibxeXkF z{GBq7H*$Z4s=tQLV-?$kW>q>^HVJ_(C!5e!QLUY@s%Zh>1{h{!Q!8nVXOpcRJ#(b( z)zQpUzOlW%=S}e^=MQB>eskT($%E;j&EPS_M@~MKuJ)+B;rWB#y?p)VIGx`E1OGJq z?YSE`#rN&w1^&$wAB|0JZ+o`otrNc)`J2AjC4t#%$n!$i$`BXjzWv!uFWD$nay3P= zm)IAM>;;s{Y6xF=7YR&GKaBQ8%gH|2=jo&BFL)n;L9wbn>X!_QhxC%>jYVH|v7h3Q zTmO)L%0`RjyUyRnT&HKVpGtIaABdYM@P=so~$l5agne52q~^ zsO^-ii7;}nm=($eKIgqIY5i3V&QI&!U4!cXp+h4nf1dHr(7Ej3%7EkGAq+HGC%x@G ziCp;?k%R^kQyxe}Gb@Fxm+{dQgHX(;--WzULGF1;i#t|`LCx6QE-8o#yL|deIHQIn zgn%&E;X_3HVz5KOvdF?Vjv{Al)?q2=9k4%V$456l2H{a9O)+=y0oGR@)xKV`zInV2qda>yb(|LOWT!``$kn}lKkN-hA+mGt zJq<5(a81O>cGdv#Ki>og>sVJ*xFJ?t;RQ@42skI;N2e0mnx8{yx*2n`AwJA1nb9${ z)4R3~vLgWwb^S6NVm5cyHPY#kym0OxwqE@s7R8{qcJ+l^Y0F(YD+-oUs~v9YLO4=Q zjTd^VNS~uJNS}L6Rcf(Tha*Xa!NSY3b@wH;dcj_C*HSOXY|RNk!l$c3;7BgFu7XjJ zBb7D({lUW67PBp*<(a z*!acn?$jx@tF*o*mI#dOKbYzx15Y-lg6IDtIHfvF?M?pO7oKj&taU`=`%gc2W_ZLy z{9^)XNH(XMDxV(h-1YpHBTx2`EnBBQ%}jCk?lHa>p~Dj4IylZEaGNgEsm$aWP9Y!e zDazHqRLEyNi|y44`JA}e{@*k=it>SyMftpNttkJggRS#>>2>1j47Y}B7xxZ>V}YoZJz_4XcJxYTQPICo~8TOTXGvnT&|LB zqtmJ$R$DW0m~XJQ8Pz6>quf^!)iyM-TG_lu^42Rtv|TVtN4OyYd$T@>P~`M#tF2%% zyEZ^;i#1n*WE81&O)X@RWd>3b=)aXwQ#g_`8e|k7Z8GOfSR$rT?fu|v#%tOVOUEV? zXUE6dhrjkwz#^thX9kbOesXB|OLgIq$=z)m#kSPODqm-koV%j-Z0PH_IrG6-t7mJt z`~9s44v6pcyp&1T&#a$IllIWIEZMw?s9xNbU;B>t;HHcyV*j5JcK{~~?f=c#|A)HR zxFCNAj^h?KA8swm!$rB48|EffY(JZ3`70m~Xl@`6NSKRpSC(>tgg`e$lRzy5N;}f9 zGCN4Ek{yIDhq9Kg0&N_YG`1xdrLWXTdfJlJ!Ajwy@9`yI!2pU*#65^H?Hz~W@)8L5 zdgv&IVQei+(_B%mi5KNCPREMvKUTD#jkEg=+MDP&0sn!Od-*;F1jcv>wIeV} zB}xVa8};uIpcl6xELk&jv4Nc$5>n9-z+#rt!Ldj?6wt=XhQTf^<3IZCAFm2dK4*oR z9KBAtC!yGpSW1wvFfDJm$s7r+=Xm5I3J5Q90j`$2#aP_|Rxe+wW>lmFy{}Zq%spI2 zY}8s+*}oGFa$^5g!sB8KDA|=c!QPTw9y-IzZBF240tf&S-V82!wou3JHj@ z7@ui`es=*@t{SS5@@17A!vQF=Bhf`E64gXgkx(?n@M{?LvIbGaQ&Qd(f9Cw_3oYB@ zBjU}+uOA)?hClk5*m>^w*1@@1@!Hj=4wAYz4*to=%&|Fgf|UGt&NkL{Y3#dE{_M6N zjX%A6Waf^T|L{FBH1xAuWb}JCu8B8r9x{#+n1^3xdg2{6ZxI_E<(+IkpI=!%+_|!R zR#;g+r<9`}V)6lj&3~%y)VI}dBkqQgJI>|REXxk6TLE`PXjrWF2iOf`63R8;6+;6= zx1?|uR5tg?7y|~x7|^l=0oYg|90T9MQbtZT=ktTF*3N08~Dhet3zO%5X(pGGNi=d?T=!%7S3`P= zRf_=m0o=OBFj9&w(ilWSKmj>|V&u-b(&%jyO;K^`A|@wp~0RzISRo^8vY$ z?wr`u7f9~@&cF`AGc|mIc;C9**_|JLUc4dpWisSjWWMXv>8mgABv)RT4&od`oMxPR zJJ}r0b1TY+H?J(8{Zt{xxys}Nk{mHxvHg?M+J2NP;`R&iRpIup!~s+xaR9A^+u#3L zxc&VP!tL*W2yTBRLMMF=-2VGG>6YX6lP$n}^7RJ;_X|%hp{G+K_rraIeM|KqWmPG4?CivqHFZa0#6Bo4DvmmSg3sTaTj%EaO?7oFmPWKWpimOj>AV((7TBpK+M| zkltP*r{(4yNHgoO=`lUS?0_>fOYp_)YU*<^r~^5fx|ot%j!gc!Zv1BtpWOTpkWvb0>Y z)5H>TOKhdESi>Vr*EO-0ZfuFg|2oAD%(n9(lOl|d5qQi~iQ-NUW3XSKR*B#ZN2KBi zK_b7E^L$-y$n*_IKC?I?=YS=g3sB=5sTgW7!exiV*OZh5EM;9`B5+E8f@~J^lG40Y z{Na{U_7YgnTbRXzQv^0|L zJhAeZHV4I*rsbrpY4L^77LuG8*zq!NK9L^z#WC?!@j9##BXnJkQQy?dMY#m`0||As zJPEKZ0OR12!yUK>rcFW_aJIf-CT4O$8h1>B38vG-$6Qh$b7~fGUe+*LdmEcNxe!1O zmZ@lutf9tl!K`uBfU~K$7PM3c(nGpP!hP*1gHE&3CS0i<@(Xj}7*ME%)_~!svSu}C z_;E{}Q3f|#6%|6&c89wGiGye_%D(6biN5_z_u%;TkV)JvOz%1nn;1LY`_ysqU&KG? zU0>%u+}6hn(>nLsKP8#U2dv*iz9vGxPCgS@sn6^Vsz3q%$bHPb!`*3QOY?IhgG zivP>#Bd)|$`{g`tfIV>_b7{F%1`A&yE-AY>4~$KUC+iq~+e*<%T%8H8)9~t9p@Ukv zp(XewNZ7-ul_hd`m@9HfpVvXy^P8tn@;4cd$s2EQJb#8>>!@&zD?zM#qtf<|8rNdkV#W2qMFO} z@5~(7_DK8AT|3jedQ!1wLWFC5U4xlSJhiL;iOk@xmffLbx`+N&LBneV`dcfwXBom0 ztld63gG_3ljwQZwh$}0j$^Js~_W}zUx-D7fg`BXSn(h}0S^-R59XtY-kIM}pu~ev7 z{&dZGmm6_nU!{wlVG)yn+;=V`h^&;|z(*K(H81#+e>l{-KBO~fla=lM=Yk0+@(LPs z0^b;D^=tU??SpZTPN%K=#xq+6<6fO0U>ecyj8FFaf8R~srk>|tQNFKMG z^M2lT;skwPKX21yR{6euzxr~3y^lYrI-}lBZDS+g_8{7pAeGgdWSVci8j}(bU}Ym= zQ0Yk(f3PunHtY154#X!mQUA*D=G38S@fA*SO%wHI^IBwy#4m)GHRENq?6M^?&SFC< zWCwN=A;cdnD;=tx*i3dd)<4yGN_FPYG}$TMe*ep9#8aWJwdxevNxyF;2Z&%~$+y)m z`L^<9OGt>!x=Ih!9^FiKHO00D_LLt54m`tSFiOuP@4VDRq9=+2jpJ)%YsOE`@bPOJkiPwt<+_KM&aCw~? zQI7J2+0H;>gCU|NpP#~rC;;8W6vsg_;j!&6)BRNoi8i*2AMpl z9;F`eE%AKufZBwjcujqd#PIWdFl&I#ldw-UD?inqaw|TycpMbrQ|Rv{G58eT=y1}X zKiWcKDS9ei8{(gX5Bpd=zjy>=_z9m+N~0kh46D59VpAhri*220i`rQ!!zDn5hLktStQ zQdaQanYgp|du#t|?djz0wRiAO!d>Hr)Lp8}R8??##C;^A{8*Rx;)l=h0g@dTuZh=> zLc1>7F3#F9j2zNMdfq=ut}cw;Au$p@Dt3xH{-5Fa`>7^=TQf)JRyBEC!V1=wF$@yO z7gL$+UMM?+7vP7jLv;VV-~=Z{sG?3v5b6hVf$AjYm_yMUZ}VXiaTq8pU_}I-t)cEE zvqp`;<$#DmdYv9Zlo%ceHGl1@Nci@S-{!s@H(06SCy& zY2?zWPTxJ(^8J7PXZEt2zFc-87u-m#t;!-wGqtt?^#D;Bu;hHrcXPo?9h5s(Hs9s) z?#d9_TV`HmGTZEBUSFUxSiPJ}QzM|=1&~)5B-K-^1ByPXtT`ygV~dX+utTWbg(Zhl zCb$*RCh0#l&5VTjZQH*3m@^Y4bJ2|LvHe?}qxQzHHah?FrCZMC{*?3Vq4{opgul6m zujrkf?OpiQ9(wc@v74O!3O(lcExgGm7QTZz8#YSP)L&L{oHb|-s?+~{5&nyN$w#OS zQ%T3!!?GQ+Wl8idc$XJyf2$y3Z3@w03}QesXRfAFgPMgcW;E(bgE^j8`TR+iOP?1U zPI;J15EX23hZPbG5lmLfgzzYa_2O?wmN1l80BM+AndRWc;q=vF3974hSq6Rubu}yO z%+++dLQLWZ3GkT9rNDv~JVmc>X$?I@{sHd^*iM4htf@Iy4V*OYGDS@eby%t;MCT~g zRzZoe6P^KkI~>|Oxi_@e8zzR=d!K0jfvUvZ9Sia=7WRcid)2;4@$j*|A%0`?ot7#7 z($v`N?}o%1M-61|l}{(8sAM5oq*#`Cg<)L$z-x#c+a(gmw#iC+7Yq?qxm>*9ZYW}5 z>h;L;SR{B{jI6O<_0}TctfE(~^+*H{zS9GRL@pWH#NK0ihK>E1oS4K3*sIxJCcoBjokqtB12FJTn(F^pj@zW(^~*Z&7= z5UET60C?JCU}RumU^F&vVczvOp5NvxgFOcW2%NNdsRg6|AN?1=7s5V|fti7Wfe9oE z0BBDP+j!bzU}Rw6ko*_Gz`&RG|LDKQU4Z%LcE%6Q%VH8S!!(-2m6PM8( z`hXVDHhSqdekA7!_TUOm;Q(6j3O7)NBX>T?mHlH_VZDr=zz`(iLNys#wEQittxw4AobT_(RmBbW$~AA^{nilYo5Ntj`4iXd9@pWH*byg zjJv0obQ;WeL*F+K^uc6cN&R&r-en%09*0SWW)S5JQlVaSXlYJLd*6+m&Ldj05~21t zi+{+snbv!RN$A`XT4Ph^jW3Tmc+~WIdmfGHJ2a-FUfCG?4zmvPfo`Mu;D6K(@dkNn z6ogpX@?F>+A(jqi`^EDG$xFp zKE(Zk$Ap)S_X%GH-!J|c{yhRd0!IYR1dj=E3FQd$2^Wa4h_r~@5cLt=B^DtrCSE7O zCXpe@Ah}PCbiJM=B|7Z@xu zcx5=lNW#d%sK}_#xWagv@hg)UlNY8%rc=yJ%x0MFGy7-mWIoM&heefTj#Z7dg!M8T zGn+HE5A0Ui*EmEtd~xh^(sH`syu|sFi<8R?R{_^qZu8t(+;iOTc;tC9crNfN@@Da# z;bY|U&$q>o&F`MyE5C34O#XcSQvPcGxBQ>^fAaqqz!k77;8?(=fO~;qL1IBlL3%+} zL2f}oL2*IHf?I+o1kVXx5xgb%KuA(3OQ=&=Nw`?}rSKmS9ubFdz&aKut7_sITNR_y9hDPvDbyax2>6368naK%1FsaM+;T^Wqsuj0+7ov5^@YZoaO~NP zXDZFJ>P@X9;VJiGXR40Lq>Tfb$*tf?OetkpqWb2gR9^eRTyt)Isb&lN2adx9b*?@B2D@8Ub$Hr!&{s@T zaTLe#?ag1jI6Pd(hrZAOhOlJl&nZ<18P%ajU;4qDB z;u?GT$Yyr3gMA$3h*;UqI~v#{krG9-*x1TVK1ekCImR!3@|#1P;2w84$z0~KiwYi4 z$zAUAgoixhF`ua7IZt`UDXRIwZeH<%m(=hj{KIX`C%^(0v5;C0P{$G$6QrIHOIgNp zKC^;VtYkH7S;J)xvYvHpU?X4o&J|vBnloJG4exm?F=CfkiIaFqkVHw6WJ!@!Nt1NR z;4J63$R%!Zo(tS&3&$ms>)enm$)-tiBv!ynN|&-oS*&y`Tkm;Hb#+(Q?Nx#5P_VM1yuQX<8Gcij-|7nm>skh%%Hj8# zIl>xBhtl~ECkdV=0Js7Fg|GpQ086k4P*|}60ghR*Mg}WbA+QixORyADSRt^0Sskzj zD_mFrumvDRumdYZ0k8%jMX&=aL|L#DD|p&tU=(2B3i*AMfr0bHzW@dX_IV5p42%rO z;1vLZKLy_a0C?J!Q@IVoFcdZ9Anw_K3Pn`Zh$a;SAZmIBU;xT&fKoF8BRB=3Kqy5j z7D!Er|B=|(vIMrCzW?ce*it36&?^(Pq~@hcbEc)H9RXxLKo=jR8ttSS--x0dY+uGF zX~`DPwUNgw#zU&8B0Bigj!%fM1N!bad$%5_JuP%DTatZIOYQ>XAtXzyRtI*BXifP- z4xk%)v9RXh^fqd#_W+zv$$4I_nH3!GsqLo}-}WEw;h9WM4rUsa>8Gc2c(C(gurA(& zV_=Pi52!b7Og}xH%b&w>;El!mK#ZJixc6`ufr5daY2XPEK>kp6S*0Q}GX&-wp9L`0ONf1F7_?C&37YuE+Ghzbdd{BX5DHtrAb zfv^CevWj$!KitfZE&l^OTRDSbLu-9I005Zyhfn*#-IEI$xS@*^J^%pn??=P_AHe(n zA~dlxwf^BAel&GIdSm!Tx)M`;$DdfR(jU#Q{{jR6VQS@W^20R(0P21KKvCGIVo%0BrH5mARvG~AMu33*Z`KWnSuz@(kUyu80L?~-6~KRdMtXWXAO=w22zmy3pnYuo6Tn9d z005i~5FX&aeglqvc7Ok5|6pgd3I-660_Gr-t`PueWu=srRaWIMxgNLyDf*bij8Nb} zkib4$G}dEZhF?@G@0e_WV6wmiH7j*lUQTf8g}yNBL92nf6j&)WCiBZvyzMxNSsU!~pP9+)L`x#a{sWP~>)C zJ-OQ2`Z`BD2mAY*yIUAYXsF1rh;T_U3Gwlfu~8~=N{Wio@-j;^3-j}nv(w)gSeTh< z8R?p88tUsSYpY!BoE#mk?QNcJ9`5fiZ?6!b;9#LaA;F?TBErK1LxW_*jE$~Nk5cIz zzN33Z5Y{9 zv{N<5YaLt_C3wTKRiEkG+N_7-3)pP7I$h77XhQ^tF>-i(?(R?p7qj1gRdv#MZz7Y* zoaM4+>z{47JHp}dsSotnBVc|ji2UhSo)=(PK%N)_fc5MPpGJVJj*M$8b<{qO(MAmwVXjqv%4%@xEV|z`Q4`s0U-KRCj z1V!d${-RyB`7-ha?(%+*b3+8Cm}KN=m=f>=^>{JanBTAzsJnjt(XHduf&~vjnOE9) z99A0pPC3%D#%yL~%5b$KAmmE}H?ydU=AX~yEcD=wF@SP-wW@?AEw1Dn6|&Q3)LvAg zVd`?R%e|oHTq%@r+yR2CRn7?r-7kO&exM0wloSjKT%lwT7$6Q6kl}Ex=cAD0O$cJJ zO_-Z%)vxlmKVYFRot($+nlMpZ*9@iiK@`2&q#H_rBVGp#IufKa z-QGu(jSb%YTemZL?Co2?e+e7;8#V)^H*PC>>w8wic|ds!25;4trJ)Y(XAb@hU;rop z`1>0G;HCCULo7xUn1V<1A zswF@Hv?!@Qh9p2yBtu@5G?#Q(UrCo8k17BqE`=;XAvvD}!#p_`G{;;dJ!h41&_9r~ z@%^0@PjfHvwB@r+8$Missm^))?E^pTXdW{^Ih%U`IyJ&#hZ$psI9S@9MF5n9P4aPK>O1sFBLwOQ0LI=Uy_|a-t6}xINe=RMlOp8MU z`CCi~BV_7Lc6x_-Z7TGoF&laNbnpWK`MRDOgSuEcR?eN@C$oN{t7K2<-lXjIk=|f7 zFj=hwycHD)TljMYLa{R3d!F16JU6O3Z>l%xUmM3s2fQUH+w-a^o~D2r7{$(idh{6+ zU?~C>IvCFC#bQCl&3tI=d+)Wt0IZ<2zqxk%IzI#J)2+ZKYaUi}s4z-*&$E=Uf z#)XZR^A7oe{h7Vv)`hK7-Z)c>z17j;+`4Y1v10AjqP+*tce9LAj|#& z%|4BPOzD{&m9=P=`H{4Wk?6@)<+w*?)ru8#5l%BTIEJuC!$y#FTCu~8{}Jjuao*OW z%L@O_(x4C~E2w|fVzt^);MXer$O;MynLtKE1<`YqqF(QzRT?+|mw(#T9IB(*&#!06 zd8|VhcGC<8u}+zVKX*(Sl#Z_qWY`uG!9c&}vq!SG1=&hM{*-9Kl-sHaRP_co1eTMh zd3r661Y+9130wYs!}*=mdqP!>n`$-!l=FZYS%HiN9fkx>8W)_j7u9d83jI=pB-5I7 zk<2)tl_F7OG)uegkC&*hvHv8tTQ1~XPXIN6c`ue{ryL|^w|eP-1uLRTE`MkT9%e+3 zB_>!;Adg3)Ip4LYYo)r}bS-xM+P(C0G-)@r&RJ!z_&#-o+*?DIvY?VUljSx(bi|6p z5l_BT!ff>o|C(dMke!pK!-u9W!j6Hd3Aqo3NeDItGL(S50+@+ZQfrg zaUjcc{BeT1N$|Ozm7K_qXJ?7?jHfje!k)61PMPGg|7Y!#c|ietT=@1Ph%wVFnjHBd zwP6a_<4i~$qo8kW>L5fri9{$nT7MjEQsQEQmePhlBfb+>$b{h^*04@AaX9vZ-wqdgj`@CYH}MW;`sSY2@2tTV$b4A3+|q5MbfBH^!*6S-QYdvzP8?x zUXEI6ZwJQPR$+jEgJt4ax!|*pbFrbYAL);d`8N>ijagR;4L#yoDrKqJPOiMI2 z-)0T=PM_Lpugi94%hv!*8u$`TlQ=F-RXTH<^{{0p>vwco!e<&K;}@1^|K6lthMN@H z&t3>sa4L8wTCJ6~?;ReP;|D+D9$3N7L3Q#$^)U&6_auWJ{Wrp7oqZ6rlrzdmT|sEYo8+A)JR z>Ol3tN<8sSVV3>g7a!#nk107Qd#ao=VcP&#CI9z3A?XUSIcecCCq#%n39?;)|6D|N z1NE1p5pg!ID|bpI(ytLn8~DQjIpH&ZbNI3c`2-*_6bF5{VNCRe)M1>Rd(n46latiBSHPt{Y! zbEiC)_g$@wn~Q?&-?y&od~7xM%Jq66cx(TZO6FOHj;MWrUjyQp`tCoJ%ZaGcLWCa8 z7W`l44o^j9+Ddn!#Izkkf;2t(UoZdq@=5d1Wd(P;0=Y1O<1}D}U5FG?p!FX{1q;4t z3Ncw|4fgYjI`vd1(gLFJ1FYUw5kqKRD}S-BhLE zxaOlfQx~qwHR-M;Tp+HzUZPWb16qN%JJWsGMl6{uTvbt&DL*|nIf@{=bX0?MYaDx* zGgp?WOyKM^K*a=SBniEo`=Ws*kiZ5OlK0_l-oFy?o-5fGnqEGGzgL<|Tk4*b9q`m2 z-=>t>AF7po*=xEATuOb_c-z)SjmD8b2(>|-x^t)ir+Y_ZJ85-tI0#{shfd=$gEjl_#&PR`Sp zRAVT(QEioV)?8JDhF7?Ii6*S;3jZqgqO=L$d?G zq=}CVwXFyUT0o^_0`dZ&Ow_gXl;~NBuWCyZ#PPH#4Cp)74TxLndPDQTaB0J1&GC={ zy{JxLMR5z_IadUt3n{p~GlDrP*C+DV__B%_3b}_h2^M}s)>)OYCa@mWh!kT;$&bfI zv>`{?(dzCuk`$oLC=Y&#zO|UW?NnoH;ZxT7PjI7HwF>+i6B|VISzeEmAkySBTC|?r zYq_D8h07Q3QJ&7+H<89fC$&OEH9*rVym=z-*Dq?&73ZTC){LrkYi?42GN~UNp~?P^ z9YWF_DACfQf3+*NK8FT&EZh&Zsd|(}w*d}L6w3P}ZZ)Ch9MnHuzMnI9U$n1+GcBa&ND}fq%*@kUdL7+ z->0TBUfCu4vDKGg^Dde(Zma$D2C>jGAIL< z09(d~ksLV%OJ!s6O+~8~Jsx&#pWJT|Ma#`X2&070j~EwF69ruViv&u16b8$y)8h?fcR{9>*h974QDd&#h@)FSgZ}=;p{4 z63JIr4|u+{+d);CYU}LPC(?Aj+>fJ~x2ZuY&7AB-#v1e|2aKECe2)hxS|+qzX#RI8ARe_Zkx7K5QlfTpwnBI2On_WKCOrS6%a`E+xv=E9Bc$EmNsZ8L1rdfyw^vDtE zQtto?w0{E%S@Yn?ukF_OTpy==%~ZQ@Mxg6ot1&I-8(`*#bMc2q_slEMWX8&U-#({o z(c_d=_pGhC#1z?}YFaxvK9I~M5FR}}(O5))^A6E-zNZ0qBU(M*3UPz1alPBX6j5@N zpl3{jjNA%%sz$q23$O=iW(be#-ewcst=UvWA4b)n)tuEcKrH(WrCuhUpt#7Z2 zN4%7HF4CQkEH8E5&4olObrrF^ssN*Wq0;V;tA_w5I0LaDmT>}4CN+h62P8-ENi5+P zNy2K;IM_?kq9#iOs3~oPjGs&wWCk&7MSNIDk0v9rAM#4{>(gH_X03;yHOc{69+hYv z{v37meEkwx__I*HFF^G4dyZv8D)E%K@k*$r+!B5lTG{V zaSRI zmY!Ykg%R{Bsh8!J=tg;)YR1TMJKn;2j?dfpnayKIps9GsvF``SMr=dpkS|kwGP6l z%6xG-dRhv(dvznVz>ZXZ@rrH)>%(|d4jY2UxNABU8kt6T&h29BBG)W$Y{}P@p0Cpb z1$&QTNKlk9oB(53=}hkA3NVYRGQC8KO^xFSlk^bF8xZN87bpM_&6q2FEDZ#0U7v4D z@HFf-Px4M4s$g%WGksn4_e0Rvj(m7NPt$kD=yEjHSnaKkH~KA?X>%EaEC1QyYjsvX zhYw1QY~t`#m-N`fgruFllr#v*o0<*&D@9^e4nMG251K_(nbc$EV858=_y{7OE;VzDA(0hB>$*a!{68svn~ zbmXq?24Vp{_9w%X$v}XZ1M-IgU!w#gHo$~DCEZQ7WerrvIQ7R-;Aeb=d8=O#u-NA*@B;^%{>8wwaGPZnoh07 z$s^P5_KwYSB>dR_X(^kBDUi7JtR+BarFu zOV@<)L(t_?WW1~eo2R{SkG;r{`k^ncx(iX{<4DDAVz8Sa-MJ-dOxlTbwlP1V+kBYt zJF!M1=O-kae8rM6X|+tY`N(j0FWnIyd#Q|Srf0kimw1Owcx}dB5%+Wg1TtsEvg6_} zGOQbUaKsmX*|(dBDWNqy&nT<4uFrO!quNMMl>9Xt(aT%rb?8kZ`1KvTSdW#0NNXMV z1Vw^cI-PZ*61HA%ncYXWRYPulQmDDnZ~Ku7rpJVWgY-bb*anPS3N_7ywPM4t;BioU zXH;r%8D%Ys8)FJ(`=Z0r2C6b0D$^|0sb3zUyAHY2n2o~qhNZx9ILwuWCx3`l>ZGGz z_sdGs#GE4QTXgGCVMm6(coSj!yG%S9XAB8=G;T)>I&|U^?Xcq$G2LJyBxlmmYJvTl z6tUexNE;^i7Z-pNv)S6kgw1NPA=%;-u=UU>1t_5B=AhXZxfCeW<9a;6og`rO@Hivg zG68F78wYa0g%zYUV4{RqoR4D-2U4To4IXy7 zs!ic+rxCvtv5?*~6|S#hXg3-UDioC;`_bvN04pv2*j~VTx*)t1YSa62a4JV$C5-Ii zgrOdf8|<}t6GQeo^hoD>5$dtPaU;AH+NRK(xp6)~d z6~#^<&Yv^3f479H9DAKs-k{HWJVdn zyjm)pTArp%7>*4olS-h3TTLi~kPkZwike~V`HTdz+IpsKTWWk&Poh{tqx(fy_AYUq zao2O|#Kxed)~5e%@Hk2K6mLql-1sn&=`Gq`6zm)C)aBt{Y8cX$Lptu_qyLy6{7!4N zeY%|#l~@8-cD&edwpA9pl>cSXL>x{3j@1lVuv z!HOItcQPi(p+Vu8p{_?MX>J7roJCR6id0J*+ukNYxbOT4Egj~LQs(muqB((x`8Zg% zRi0S~YpSnC`-Lt{2ON7QG)N0~^4^mPa@G{#9jpRDN^?WLKFAAI1CwRoitmg@m|4F7 zqSMMciXc1C+aa9DO$!>_3Ij*5t!=c;bP!r~HnI6!KG(Uu5RdmEAa-u5J?W?K)A6R2 zA$#YU?mZ7}mj+>1>*!M*pqYAn&uPHiQFOAyjWM3`!ofqnf}~WNS2~d^=#nDY!(xxW zd>_>Quho$aAvSDGHA&j+_Aeov5Gu0WD@H4-9RSQfz4(OzowWD>2});-GX*{HQY;VD zPG@QyDNz5&PZ;uXfUxj!=Z_DRdQ+*nyXoeirq?DiF}FXW*XUOSqfBIT?M&v6BV8nl z23_@oz6xx`;rj2UM=pusH9cK3BD$bn2m4pMj9XbOdGlH4yvUF|aax1&=`%0CU(h4M z2YY5ApZnLOg)t)R+{)w+Z~ERg%@~bZ3DHCJXch{V#Or}v3?NuX8U{$>HDJUZ%x}oY zp0&hMtG#YUJ|k7AzgK$;y4@7KlPiyO`RpAsJa(c%<2@I1%a7qNwqHJJNqx@&vYJ4$ zXn&VS-PI^3`V+F}Nb`#kRCLMnDWrR^`q+bLQ$4W38Qh>DHREIBIA;VXyZL#FyWSTh z91i*p-w_i8rO#-ceKK^xGzcah>?%?$AMHAtlmWkbD<;^@^rm(hMMcnzz-jZ_$g-g} za3ix75QZ2o(EeG7!pOjwtI33F=+-}Tafji1S2IRope%}khZ-NN>0(%ekI<@6NR4t)o$Jx}T9)!stm@v~dI)2V?ol)KsB>5_ZrLEZ%g!a3j3HZhfti$Q%m{EM+!`rF=@_n&(2$r(j$ zBer$h#33f1D@5r&uD!6KsDrz_AW@~UC3XWQ!$y?eqRLfC1`81iRe`!ACOrUnVlNmk zUm9(eKb7C6gM3u~%PI`WmS`Kqi!yPo1GP;FEIsBhcS$hklY}|%8$T0x)3%aBe?@CW zSw-Z<39+qHf-Rk9@z!?P8z*AyXPA?}K1&{!bX{mFcmXzmb3 zbX-5$gdYo25obeiF(czYj@X;V8@DV46mX${YMw&HO&Ti|SL9~U7l#9=zq!gc*)mtW zwEGw_hwLGS9Kl!=y*}X=0vs8UlQ-0?L|@Ps)bUE@#ONc!-hpezEuxKJ9?UWo_8?YJ6(39^C|)8Y=?hh&R>8X1 z@dAuB=qFz@=Q+IT0)zq3y7h1;e~>BB&U@nLTRN?ZTRNNSJ5}O^5-);XS9Wk*j3vE^kwVT1 zr+2uhnM(EL(>B3%wU1XS-i4*-1oN_v`fxFoMTf@VpG9(ryD~%Cev)Pxs>rG$71PMe zNrsnC^gr*{ap0xK2IFXdSB)~KX0)_;Dkc|887rbdLO5TCgDThw5QeZF4{}^{ewSxF z^SghqrbkNYKy}4FgJr{du+N3FL0|+KRQ8bE;qj>xRR$5u4Eb)oTEF$ZW&}}!yP8=Q z1opVorJ&c>77ShQ&TR4IeaBk}3c+Fflqms0E#Q1)A0PcK^Zo5^Jd5(4ENS7l@)l!y z`Zo#_db1W5VpN^2MOXq={Z4YlVc1pmJ{e#%CY{`Mz_#vx}Pj3rdmEp;w;#4{!^^^i&YxCbYJ1s< zWUTT@<9jv-T-DnftHB#%8h6f?%KA}KP1@X>rO0xKeD|7xpdMY@MRm6%&=U!%GPmhIx0*thy;)bOoZlW|!j^UzI7&y6QYXK# zGLy1n{aQMUWY}6KF9J6yE(8f_gG7fu0BO$UleI0Ql1P)urzS43D5-6P<-Skc1dZ!! zI&RX$IGIbJT__h=^;UTW+OssM>>wWF-w3R#Ed1vzM7ix}6$kcaQvXF8TtW*GhQH%C z@v4aA1fbB69Vn7@!y_=BbkG)3{mxWDmeuLPD?m&dKI`-I$ybg2e0CPUOK45UJ-w7^ z(N{6{%fa%#Z?wT=n&YsdTGKOppazIF&^cwTz<2|WmWZH|gDcJ(F^c|E$NJ-$HNBG-5`xr5Cwk<9hfnPx#4z(XnsF?> zMCUgfOmn$C9uOTaZXC^ZpT}Iq8QX2X@68|ibU&X-9kw&G8%&E`>8`YDeL+^GGf1((W*EGJ7)uZ6ng1d*Z^PXs6=+Q?{lN8AY7=PNc;?j?$muQ{78bnkGM zWeIxdOc`gj$|S0cMx;=NE0)qx{gN=RG6-%Ejk(#YhVzd z>g$6_!=vdrEQA(D@2ZlabD`AYL8_9tJE3$=GbP$DqWCj;=if=TmHjz>#KF^?hg}2t;}PwSZ2{|OSv-^Frm#IM#_UCF1CK(ri3!0 zI3(&6W)&hs*nzOx?}#bh&`@<+S0-0AK^_Wx`oZ!b1^NI^#sNw%NpMCod5bDZc-`Zd zVPSEQHRrz;X`nv2ss1ui=>yc-3YerF<3PLQG|fsrv;Iox%=?8ywkR4#0T0zM05Ax@p$UCDb^^*K! zSA)POVrH$2T(dD{<{B6!G^JHD9{W*w z%o1~{8T!N+GC6_olUC+M{JOXt@GwnnX4an@4hFISxeJE;uSs^s9h={2r#byn4JJzT z-__u`R<0brJ7z6?m&uZp%{HtbXy1AkQ`@F-oUiE*2fWt9%?MGL|CiT@F3wXAI| zr#f`}U7V#7&^`InEVYVWzV1UDiYzIQh)PqLb`4xr=U-akJq(Xz_&)ogne!bpx7QN$ zXygkf;m@c^A|H{iM17%Gn1Q*H<0#S;f~DN?v$ToDLr;`+V9V-!80=)N9QL-`rrQE& z3_p<>{$mt_0BvKpM2?c|$}}RjIZi*&Jcm``8LHFWTujbHv?chao7}UlQm(wOU@x5P zLyz55p24}WJ{CTgi?=OJYg97(Z~^MLxDD)Vm7Tyw&R3{tUo!~3eN+Mh zwNK`4P3Lx(z-K&FOEW^=P9U0Gc}0l!{H$zz}H`11uJor_IWkRxugr$iZs5Y^qkw>a#UqiAzo&(zv#C>ZdOZ= zgG~gPJ|@-R?yZET)kVvX-LSUve2WqO+~Yz*O4i@PAJ2!FJgPV5dh&V*wkR(TCHs*) zkw;b`l|Gd6T)wN4oM^_3&;wOt9Pi}V8 zH9dI^CsBMeG81)LP`!3{C$2u~bN~6QXLGvu@50ver8{I4Zgph~RgC0sxP_wL)L%z3 zPoW^@*bt{D>(8(2TM;UrY_**2e@CNTYrU1VUYE&QVKme||K;Ff8>=G&Pm)q>V!Qc7 z_UOvDaXvq;O6M_>FnFDqe88BjUP}hDGau;=ETpSqz%_T<#>tHXdz(RTb~#?7IT5+M z2Pf6&B=4Xospg<42y?%KZGzyuJjf@A3ZAMsj-+JAv;9H(EN>#}YIk_4nY`cm`^lEe zMcF$&7NNhz1L>@b&0>qw=WVZ2o5l!fClAIP;b!M3K#eDCwyiQYfWvUHQd`4BYEpay zVhL@IaUQze2flK19PFNJE-oD0%$ zwq731NyKhDWYmemca7!#P|I4^Ef7bBN^a(?2c5z3#3~u?_G)X*qs$#Gg{MJHY^9iP zc6Jxw<@Km#OO>s2l+0Ta-BBZY@pn6iA3B8D^m|*Bn3^`QfyhpJNuo2BFv0SvoPaAh zI9DyfS~M-qvQ|WLf(UhNUDyb(hj`tZ9i17dA6I0X43%9n8g=P$555c7Cax=eYNHb< zvO$=NT<~`ywx<=OY_^g{3TCC9jE&DF;QF)z2+o*;Ur3Yl(JOQ-cSE+dyj z!l}E)CEXhlzN7O`q|(Ur9q>v6p7#7q;B4$ez&zo1?~WvL3Z=RK%yd4>@Qr=Q%qv#=jqR~ z!MB}s(u_$Mu+bAlM}A_-#o9mn8-WaoZPq5i7Q`Folt{<<)|NJ@Y!w>6 zG$ePl(AUb^Qwh@xO3q)EXD9F|FcaCmon^ZH6GY= zeSHZIt_t*Ik*K#GPm5byN}&Bo(25{6IyrZq$-vR*Ii-e8x{$v3_HaddZ|%sRHb+rt zo1la?C}c+h$XjXLOv&RqsyD~K404KM1(f!usFE(kQ&VV~yhW^V?ngy2)Fprt&|yQR zYY{_MMHM4(pl84#ErVK)6S(0D4nKz+kkli`pl!v4vuA>@Kmd&%xY|j>3?VKgDIl*}}64UZc!S`N3XSN+4 z9FBN_&rlZ0#pEv)v-gv78yJ^ploJl|iaZ04w4ru}RKaX-pOw|)=-2fP%3)joNYHSwzBA-ldwNF2ZI9vZzuR)I;~{brv|NtET+nY0Qbsg4Gk8+|vZ0_Mx8( z$2Clh!*HgN|4N-`IFF%vXNFnAjiT)au|pqomeZwxJ;I zTjp3&1ezdP)m4rfx2O@RC#FbJ6g%zdJMHBG9_1(wN2l{&(ht=%Jw=LB3d&TP^=om0 zQjs@MIDwZLTlKygB2JNX0M;!9GdkeYjzZ3GnXL zo_5<*8*od=sm8032i_XAtmc~xJNs-xwOSP?)-R|Qa#5t31a(ty!ELPA$PlRzQKK-v zqKrH#^c(KJgL!>I(6_=o9(PU~Ln5w31E-NcJ9YBlWKvM#11vHR;RQtRDzwC9=8MuZjV1^69evVMRLTcW;u zJ{7#oH0Wv&GAdgoCKh&;6CckwOnsVRm+7 zViCAh>&-tFQkkK2ILsP|I;IRQO&qwRH6St#v)&(a)zx|rZ1}(tl)VQsAe4V3c`SeX zYH@YCCj8@!MKB#tq;aK3qMe!wlSdLbM{sVMu{F++iD#??6u>)jA#WiJ(|W+rxG)5E zz5o)yNXv*FM8*s$`)>h#5Z}uW2yfgq*$*bHswZY0>P?@EHP_$T6m*G521p~Hc$xw)sozhq3$9M4OIjn2a0{+;Ug9~f{PsYeBAkv6Kv#Hb52WY%o>V&_MB|ON z{)U*~=+QXiT`SUk!)ZXnIl%%e>C}gJ6!x-Ok!>3*316SG^MYi2t>HM{O>~>mUtZCe zRg2d>Ydi%OomxZzf%f6rmfTp)e;g?&(f1QI4<+xYrBU#OX`?AFqA1h^m2wWt2%oj(kIViW0kr%v>;|-ycocq6k$8s^mXHL zo(}^pc{5%f+wAFncEN>hdYxDv&*2v}217@g8~@UBs)H3ulXx3{$lXZE1&3;dIB>`S zhf4a9TttCqNHj5r$&Z~}cFBK=@Ipy$U6>ibk@2f#^Q=Td*{>jiQiyX|nHxsb<+rRq ze-K?Og`($Layx!Ej>(BLt}z;-nrG#G z@n%9Qw>Xm^$DdA8x%f6`)2CGdr=>sG|Md^X8rD#640zI32*@9G1-`>^ zGjs~CbjGhNxU#`@c2T9LJw7%sr9-@;T1`&Y9?`Uus@wr>K$j7ZW(w6=Dqpim8 zNL+8u&PNF7ZVTQm4C}F|jAEdUA4i#cOBA3MMx>C9FrlF!gw8}tv)o;zbeIXaURa`Ty#yBEzGV=GvEp34ts8uj>Uu)-7H>AtLuoqa|8 zQhAL>_xNIeZT|?%J`}wG5yeWiX!!^LO~JE=#Wwf2rn`0+m1Pt<)59%gm79j$!^Chmxi{NwrFug7B5c2o^B8p}iH4$9mI_??~; zAympj#m*@opF9_PgU#zxFTg;!Bu)D21TSYI5;1fAVuX3^9r++&$IYFK)9_~92D68$ za>zY+3)}`_J6!ak2c{J8qo2PSru+{7-W$_f)|A{EN4@!PXv1h-F|pT{^pHNOTeGu+ zSF_(r{4}wp)k2iOulg}l2Y*FK7EnhHnTaX0<(25WAd{zIFWYa<4KLgwOJ<7R=e*gt zvegklAaP!og6SC^;?D1FnDDs%9_jmNgr1(GX9pye7|{;mdl0?9`iNy%O&J}MNDih+>7=>oNIQ@VYg2pc_sO6i(s;%W|d zC1Q%m(3itof^4li~|dN&=V)&f-vIsFGO?|H!-Hr zj+rsHR`sdqt&M9E#PD(y{^=SOiukO(#`>Q_H4j2h5@Bk|*&DG}dY=U4e)gUz+cjMA z+rY4jzhUVaV|e746=C3I{Kk%WP#dd~bjvQVxH)YmYzIT=U>mUCDqhH7_p= zl1+KGqSPw5Qu6rr#)xUQbG~us+d6AHy?=l~ZZ8_8+EoAD_u3$kNy*1Z72vZd)Byp- zVGY<7hM(kjV`qx2wrfN}()93JSmf8CHIasaoKtnleWMP{jtp4X5uRK%WlmdJpe`8) zLW0vdYLe|`L9vw$D0VvNqcB>af?gJg`aUOSHI34^1KPR_C)r;x4ZmCYsLgO?QrE@BB>s$jr0-VkcM-DCgF zU-2~lVqQN2|D~Togq*z;#+{??(^O{_AFTta;3)y;=aVKN$|B^qLr7==U1iCi4xOSS z)T7WmN8+sJtvRho2%&qY|`HQ`~eTmmuJmjmqP-PJM@j! z;=W&fL)Wg>>a`W8`qn<#?Frpt?;?{MIM|DS)ea8;77U`c+?`WGCChnDwkFwJPDx;< zOBoXkUgUoA#IvW)$){uceE~4&;LkT)p=f1Pv!dYfc@+z}2N7)&56orBVaaal9S2LA zWr5*!qy@0LyOoUlV!Z@M%paApV(3wW4qa)zXa!#+)Fhfcw88euE)x~*wdGP2(Dm_R zTK;$-_afr6>5l0X*k^|(TggGKfA9bGDPwpJkLvPQcXpujZFd@*uDKphpnmdrw#&L$ zbIs#Myjx@p+3eFHeYc>ej&_3WFBsA(!`WosP6m~+?Z3~#8Mryy4=C!P@?KMW#?4*1 ztaM~Q(O7m8rQHl*Lxk5Mz0OKctjKFZ^4|>Es}ZpOWoDqv5~M3i3wDbvi=%$p3yR;{ z2ts5JP#M1Cv2WE$J(Qevr|7juSK2}4G*gL`dA1|wFBgAwhiif1VZvYdYxxe9*YfN? z7`k*R<+)CZOG5fMM(_oZj%L8QE&W2It8tJc_lMZzCYKPWH(WI3oRp$K&($s|ALI{Sm2aMU6 z8;pMD7UnFGJ|PFq>woT@))33KYcDKqmwKM>y{zt^M43x?8%vC~j_oaMo132ES6?F2 zXMy(zPcH6Ty-k{|zK=WHUPRYt7Mcs|u(o3rm*oe%3&k2JidZ<+isjhN{S8INyueOY zv4(8)_zYa6Vsv5l*lGBhhDp8S)1y9XB!NLR$;V?z#t<^3f1v3~-m3orS10#1Ipn4@ za#q>BjalkjY^g4t^^ndOX78||%FLZWli`=~RtT92?8#T7yayy7-Z=ciHUCT;5MWn? zNxP&4A6C*~8?{f`g>&JOjJ4?G3fCiys={zSu&bs&%P~JI;wv>RDAe8*g(-ZBe=7BO za(;X!3RWoZe4p3VEYJaNDRG)?U)?;gj+t(ljoMI)F+mk!dq9W(9}22S={>6;s9C=r z3A$}Ke9cRf2B}=jF|~0<3fS3#h1#OXmRYq#8t9BynB_&8q;FWykP#Xwi{}jVr+~t$ zOw$)5)Mz1;=_p(D%SYkaD$;M&Ca}UR&1m8sxcZmzUeUjzS8-SoYx9}?CRyvgM-IQe zzN90DNab@DYLwa_4(dLMXjPL}(5tav$Y2e0>-7okP_gf+k&oPrcX-VHO0l48RP@1) zh9_p+dA8Sdi%lkbNGaXuRgbiYJ7`PLHjg7tBrp0$MU@;dQtXFGiEQr9iU94ZjqIvp z82UXs1Ts0;bD~!%F9G2l9U%eZo$z}5tH_*x7^fgk{^u#9?fm#5{9SjSi|%vY z6Yxr$&+FOFh}3z_q*wvckfO8ETxI$E%**Fnd^7NN1fdPX$tsn3ogwlht`Zl_+O;30E$a|E4> z%6-a%H!f}3aEGS60m~1*Nxxy?%5gzJFF}Z42NaO(>M*>J)A_$7^0&9D;ky1k4xcJh z<$lfzu6O;D(C)BU^v=$H=e$N=*GQBsVN2xF?BF`)>R5ZG))>$wgc<2Bvp$1g*fgDf z(7``nP>sPo<&ZE*7*Py`=PSzLZKAwf#<{wQe}%za|6GMb^6XJc^ucg*CGwS6{^Q9y zyd#uN=%0KuqEhKiUa077q^kt=w+N<~r@haH9bS0$b$N(>CZb+JzImowpRkZVqp6mu zs!=LT-xT4_22~|ho!E0|9|oU{eMKw@z|@cw2T}sJ8zv4dT1j6J1=zs~-0xEhSGVCN z!x%pN{d#j@HaXYa#1phmd_7qz`<~VX}4lSlvk z&D$-@7U7$}A+*;C1YtbJFqIr-IQPqxByV==thv1Z=r2ot($awW7CLeR$v!{avha;Z zvy5b0N%haCQ6QM9D+6JCVFpNxMP9DOm_-RD$q$V@c9g|Rt!Bu%K>dof3dm&i+Dpkp z)Z);t3f8;499XVdUmjD{50+lJsj!BUn>HUxyXcpvzq>AF(SYU7MAV#XR8VpRt)~cv zrZh6Kn$0{!)R;VN@&NA?1;7~Hc>-kZpe`W;Q^Y|n~@?iqOQ+J?eqAwY}+~Q z{H~ncR$A=-bY2G9*DIIK#;a@jhCoV%spd#*>=Z1h`DB^SQg-oUK}#_Zlo`LP1|8oM z#{FnU&}JW6Rc=-CZyUozn%Ui}LisAPocO*zE!p26@xcLb?`tU7IWS1SjZ`m&60>IL zNThQwTQ_ExmU497PJe!Cb#`T4WE*2H%v^46@2I+rnYK+sj8!EwnNC9> zdqhryjn9-OvJ>7&h(Bev8jH3Hw+yto)A(Yj$hS{GRF{exV{QCungMlL)G&YBu*h4S z!~7l1wdQma5o!L(WY0=tYGgwuGdVhWb#c1Ov_5L$eCXngx;kLe=kVda%iOa#eYvkj zgM-s0;^+&e@^M1GB&=e&D9Oq>?-(R0#m*j+3`tn#=|nf7_Y|1}4$cF|nKypfTc%}) z%^)!oXXFn0(|(49Lq_5w1>zViiPoZytNpbw1>S~~6*v&!(#m(3kteMgM zPp`j$>Ils#6ux-$F7;^S5AIWIClOY-%FuCj<;6=|+gp=%F0|BX52nCCPcBkzs_n0( z^=-XkLJRN=0@y>w!oSdJ@CGC%`^L6bZnXwdzp3cf4J8ni#i$K`%`LDz!6_exOh5=Q z_hMqd3LRGossGp?Dvu;~t*C zbmKa1Sd1eM?|=FC>a%*DOv4gx%rB}dX@0So`_d=MFM^*-N0xe7Srd@2ms-wNy;Qe8#ejFxEBiEAhT8T34zAq$d{Hb1dM1}zGqV`FnI7dM<73qXz0 z5;2rOwn@i!GRIa|D;q>bunu6lMsFS9Gps*C3k;Cq>9VAN7}TpILyY`+a4PG&?-^Ru zP5Tu1({%oah4XPO95XdMNX=19x@d9aTm_L+t02PeS0`2w@q&qJ8;^*pN1vP3-cat= z3W)5($_CBB9+ezW*LJ^pbk&ZhXU+V|iq-{tSFQegUB}_y{6_ue(k1hjk>(FRHLGd% z#`LaPSlbPDUOH#zCCvo>ucXH`_Aj^5#~pl|_|@0ju=@BgxsNPrQ=8T4ZNq0AwXGtW zZ3WgF=j1$?RicwBaC88DnuWp}!Eh>Y8BErQY>Trx%UH%m`y*Y2TD5~dH$6O~rx z%r)^;4a<&U6()fS^9(m+d8q#KAV*nZxm0(m?h>n3G|*>W00zx^_RI_Yz>&D&<@pS` z788z$@kREH#i#7U(#mKE&pa9oOzc+X0~^o_y4 zk_1_?bJ?=(fBv(+p!>eT%lrdZzk|c>&!@?sRChX)Ns|Pd0hJH4ahTgN5E|Q|eX`lH z%vv6SovQ?4M;p{!bU?k!i%^T)9BMu~83oG-QM!0(DIGo!0)qt>)5 z`Vba5gAyk%WvtpHU)NY{2`R(L_Y#;y#ptq_>>yfG*MJH2EZ>l{%)E(`{fb!2V0dD-$W5$EP0&+Cep`^db}psd{4HqTTXh=yl&2c~~7 zPJX?1v5(i;XUt@FekH&)3vdl_VJ^lcNF%F+SH^^a7HJfwvMNq1X=N9>W=^VcvSZ_8 zJS?FxmL@bZaazq3ABUX)LA=K_crd5Ivz7vS)q+giK()9tru89%?nb{JwYV*Yb7pCd z2oyP;kZeR^1qUzzx9ei~paPVKRnb^16G`A3BDFx+i3px1FqI0}N?t?QV`}9paMb}- z;4Oras>@&gDx>OZpz3k`O1uE5IssITPv#)mF_qzQ@sWs(5fdF=nLJ1B<&{#|@RsYNmD{4u!L;8yl8wx&I204}R*?Uz>G* zmr#Hlq9e;0hw$(Gu*tt_-SU--f=%D8BR^i>TC;W0q zk;{~!S60gMDgNj+_7)65pf zQe3{2Tq-FX&7FAak!u>7NSv9aOv*drk|A7<%6G@M)Z_)BniIdheJh#K(w$!CO<#Cg zttH?8VE(=bBa!C1#Qw>X-u_c(cGx4rr*lRb0}pK$}7!{_<9NqkN^ ziO)4MiO(C&$=Okp_&g(%_&gssiO)?Z@wta5@p*9eE*^2Lq|41F@u5ARH;M1slA)VS z;)^>%H=4#b^V0eB|GIV}pK*iw+=qX~seJ!Mm|QoV@Fp<%pEI3M0Q>uf6AC|b{&n@) zYsVCl`|g=;4)HCH3}~N5xDq24lczMF2%!e@dI4Ec*KWE`HC4_ ziv6SDf{%*&1aQIRLO5i+5xuM?+$)6Zen+X43fG&%N_sl7bjm@y4-5 z)kRf1jcbT(+@OP&J77ZnhP40RASV?^4grea%UrG-KtI7G1uFgPp#8!!gzJx97!BDM zUO;G)`(Jp0`2h^3TPaK{xESGX1=CCb6Cz-;gxnKJH?I53~9G^OkBwH4xsw3r*X-#4H2R2k8 z;OChBBv%SH)Y}?vTnsmo$B($-X)z=3Fl!U0v2oc%{biE@Y~JEB4jX-o^_R0|k)GmU zi5m_Vq&8SNhPJSj1--p;I@PS)jZao$B?kq$C}5x6YBNQ&niJWewV3AFVz-_8!&A(> zEyqg8TAXezI0q2Xe&;}6u^+R`Wqz7nhPR-_RqQXjM)u?M$B@LjgF+I^BEt{h#SxSW zBm4|LnjQpTW=K(b=t-Q#Nr#EwhZ)@@g-(tET%)Ev0sJ3>Tm|s>T*$?Tw z#pS^eoedq96h{ShyXdG-Zwb&{c_@s}r7+QFR1~@CcwC8&$F+aVcw9R1F&B7YmiVlAoU=UVQ%$p~Hb6F zvZXy`JR9mDN*S;uw8xm-WVS6%rnqjt?cjN^H?JRZiw5U4aLD{mhJ%P{N3YLMi3;P5 z#kYh6*qGNrVrc96KY)RG9VnO;#qt~@@Ca}}`P;*zoOTw2Ao~9cl3>a%L`4M~q_wor?y9>1qpy)hJIQAGdHEn=7)XW6(kE*8o$a!TgoK zjnz0Kiyo%Ay5SjzCEP=KD+YtdoU0q54{PSk>=~svO#~f=(%du=kxj!C>1svV1x>9e zUT2OdoGBK=7#8+H7s6u8a!TgDE!Hkn;M}qsOydpRXd3UBT;+l#5FD;t_#_i~vH$KC zQ+Zur;e705USTPdJO3T)_k;Yo#rl7Pfv=C<06(6J&iwVexhjh5#I&hS z0d4&_H_XGHAS(x?tSC7wZu-zGoD;$+A^%NwlM7DWa!&Fy!(pm>ZaFbo_Zuc<2fu&q zaPGx*xWR^_5PCAPzOkWt;PR-}<&n%s8EiTCgz^RvtI09BA+o11=g_G= zef+nJPyRDw$e1YC^(&Ru0lBK5>#MA)i?M=^+!8?|Gy+nb5R8uy!Wm#ya9TA2Or)()1@ea9@n7R@O~c&^5UB7z!LF$$%sod7b@x@a zOW7Qkg{Z8L(c!d}6uGxg=CNt|Z z814_?#XiED9T9~$n^@C<9@__cfAuSRTM+wnf(dR5CVE?U-EHIWZ411x81kDB;KK`s zKOAls;BBst=!^x7NONaeJpjw0W2K~-bdp`_!UxEA$gaiez2v)#)rIPPi^;CMmkSr; zTk>jqT|g&cqGR&`6wU=|79VFx%SQ@O=~5{|vE!$iz+ScIiMo3yv(;dUfQ2 zs8X#x+HvT@50K$_uoAg`?gJY^p~ z?JEO+im$;v3e%@TK1IxhPOmQz&TFx_<_cx+O1H$Mp+Bg#&3KYk0wZAzNoeCzu-Sqz z`eoEyA8z{AHnMZ)Uytm$`%7E5erM-oXE(cmBU_Z}p5$K|}4_nL41m5-SQUGg`W290jE zUYj9VAoV$Y#eNnYzu91Ds+O-C4*eKtf3y#+_%Eem)n3D7NSL4ccWF{$bG>$iEI z<{Rn$a;vSPr!=CobFqML-g3t`bnG<Q<8?Baa*1dflJ;#~YOQ=I+(JEk}* zR-BmX_KiT|x_Qn>={KC|O!lE&dZWqCA81be$g?h-T;af_^1Xub{D8^oy;m8=G24EU2xj4od8{`cPv`;Fm##o-lL9~z(fSmvv!9TXV|La!TPP_uTFVgE8;Z_fuxrJ-F7KUF zcXV}jcb9|~-Lv?)bi6K|7S0}?JG-%itY5lv@zUh9=DY7(7oWCx+q`yCNj%#lJC@98 zoxdO)owjsQ=i<9p$Ls#_!^hIxM<1~n%!X#M3j8@vG;q^j29#cR-N>!N$j%Mkf5M;l ze*N3S*H3!#ub&*g{y-@I^GB}#tcl6QO1QpX*T&Uw32qYiB7175JSLu^LO4ew@TYHpov6vD`DKYjMb_$eMxJ$Sv6x z%~kQ%igbv0ET%NjCpDrYlw=P`mxD2U2(_Ze;&f>O;J!gpTvhNpY0r29?4i-Y2|xu^ zDY;(CaJ4avyB7dy$*$a!khR92;o;KQl4>s{L61Gx>&}XpSs#!TGE@eEGD20AD_8s? z;`B^!oa#^S+}1fMSU&SxJ$uvu@A=K#JwN)|zIBx~Q|?(mul@9vx$(gJ zBJqFy{Cu)yd3mUM;~ULUU*mf9-79r*b?fw==Dt~x6#4vu$Fm(|68VaJ*9<~&qt3=T z&VZX1ikozT;f&4^rnsNMXyw?At|P5%xZ(Rxg!0}`X=27`nxHcx@%_)U&);>U>-hQG zZutHa9!5hw+OrmMZmEP5k4H@|73edvu*KR%pD>p<($F523x*4M`P@TGZZ^l%NHd_= zk&B_d>js$y^M{!ZUO?5Dn`g=z0=eP&goat51tQ#^xs0E%X9%&8E`_;4h1HnDg_Ay0 zwbg{B*|fIAe6CM4bM%3ERDs*^q1#XM(0Ol9EhtQ(u_GZu&r=1S$xm_rc2@rinxdQ+hV`+$i0g; zZF=%>B%VpJ}^e-lP9Ghj+eB8l%}6{fqaur$>z z?M|oDhxV=BPURk*c}eBf-!ploGFoH!K$@DvXmIz9udnL7@pX#U+;#f-?E1-3*G~># ze}H2&JJKg)1pj*ym(gjx6cX(w$n^}FqBygNmi8B7DL%O3n3Ji{(MKp+^PZH=szLC% z+yC_b`|o29-O$A=SA&e~q)4M@Df~RWEBR+QuhgO(U8TeCt?N4Fjj0HValf~}#_=6+e%mu_`w%8r{7d7e( zpm`@6XnRp9KBn55VlHa}pRr6mRu_%CXbx*Rd;`XHS~{uB7rt^l$<4t zF6UrCVbj52Q#~?6evYo`2D6CyzsW3OCgquYuhil~W!zZqC2bM}RyvpD1ih1v%XPZV z5!&*?9;}HcVVo&Sn_DdK<=H|<2^Q-Vj*LK&a1N>?*CVBk31Lr-7HP;GkwiJx5<{lN zv53}KR%B^jmnfNX<%!xWGUI* z)jCq5bMj4fOKTU|O}?n^QBM;O{}M+rV?M#URKWa0iw}vIHm#Is zdK0VG#?X*=w#wo_@Kqsl$5TL|Iae%VS19&&M{)2<3_XZ2OFiN!E>NOMc`=(w3P!%( z1^O#&&lqhiQd{DnQ)guxonvpIvpcK6=qoPAs+}?UAi{^;yMiup#KNoKlcHx>#}WEq zgu0XacDJ`}B>{E%`OdHH=-%Bq=i7TvK6hw=&+hfLA0mGt{IYNG0m6~wo;|8*rl_u- zw`=w{w-Pc@Ra;1R+aEsYT&!lMQpZft{A?5TvrD;Of1Ia{k4q|!<3wIGjQs3r3AggR z`+QcXDZ-v}7^Rb-t<2dhWzOdR2Cv-brY&?zX)(qr%(w8)b5V*Ldgy29T!tGt=qyS> zxGQ>II0HVd5#;3m+urqsv~kDr-|y~nNi^CRO-_w2HCg6TXTuW2WnCOv5h~7&Qi2;! zM_NUcZrEbg9ediK4`Ul+Z`+&nVGlAAl`=Xu+BsHADcc^p!DRR#B8Abi2Q}+z*!Ry} z%qomB#-1i5_e(D4?|Z-B-Ti*wyU!nF^Qp-aHPRI)nTNa-_E})v4=R+Nj59&<=1t}- zzYYJZU&rUmAu%9u3};+q&KpNH2|`F7Cb>^G5yX=f1s$|~$O`$lxC9<`-g*=c^AKyf zjIxaC8ipmSVS^EsaYP*Uj+{)N>^(l5inYaB)5#-G$BybZdb&rm&-ZrrjgNNsW@54D zU}dDO``D8)AuSz@yTU+66oPtI(s8ov*8DCO8WgNhDt@%lAqMM9c}n`l*!lbL?IKkOJ~%LgC&$Oa2Dj5uM!4EJ?Y*`W+~ydqnp(dm)I za4Z@<|Ic*>{`>9bVY^e0xZS+ER@zR$cDIQ8X$Xrd$-0jZvFDYLi5mR!y1J^|g|WW^ zJ*`xYwM?8?MJ07*g)XYKHfw=iR_NPUA#Aj=v{NU-1qBVx9UQV12URE6p_1Y+ zSRK|eTs!9Jh@a*0drR}Ex5&4k7CkVq)pAuyR1-W#*<;QPIb(9g$rE)8#{zBXW>%6) z({n_FS|-o6{5_1rH6;=)b*&c$hGv=cC#mH0C;eN6iHV)Uq@2<`1sU{Y19PbzDj2h= z9lWjxh;7q~?RBxFYlQQ#lLm-QP;8Q8t+ZpyITAS5V;C;4Esdnc5zz|~<_;xRe7x4@ zwF#S5af*{Kd9}>GPfK(w@EUdrrjnDBg`J6sU8#9a8y7kY_lsMe(}7tkP`t&T)J;*K zc*iYV3ddJN@j+i=X3pJ71d6({9;N2=V&tTP5J!66p%MbQf$7&iUh9in?TRCS*NGwS zm*CS<^(%QJy&H%4^{{AH|p#4>q)e zkMgIe7ZZs_n#APllJJ>k(m_@;vpC8P30r{f>#lnpG!2X#t|Ts zPuZ-1>Rbz~sSp014;U_3DVB}HEn%Jr28{ZaaO9vWbVtb$9`AV|vMWfIDfmLo@tQXI z-O$iraeHt`ews?%o}avtN?n@CoKqaGYuCp1ZjX*CZDV_D@IG8TF25XxZlXQ%~J&rm7#43#@Ypt%oB6?5SPVU`|GEE!EDm!Kx%*f%w@ z4&Xlat<18lHQX#qdVH|N`$m1{%uMFghof_5L$qmL`M@l`nk{xt%b{;gHGc84h3soG z@%@`V`NhVAeiOcW@Pp~-;b(iYtW7?8*h_|5Bw#)MvC)*)?qjwQF5mse^4*8`<^zrJ z_qH+-9IgUv(VTPF9iTD*)v(EkE>->~-sxf~2kAW;A=RSN!i z+GAj3U||37FMxr8FO7lW|9{>$3_uYS@CE>m#|EEx+I5pXOT<7Bh9@zcAYvs*2v%~1 zT$L(_q)?6&R~}+5K`d+zD>+ihAr>Mc0THWUDc0gI(86^701*oj1RD#n@}1;eSQhT! zVP-e;J$pedh2ZDkiUhUdeL?=2P~t!rHX=llEKVQ!-CM zU1Mg{E9NX2FQaX0)piFCK_4W{zfN6a-Uqe64EfHvbgcQS?tQF}9DTHg9_eyk;S}a+KX9lVVrv&J`IP&}+FLn=u2r**Yd5lX z;gVDK9TMhFtX$@u;H`TTo%_tA$n2Sjk^V%)djlIS@(p};sMke@h58kg^(7o?4@J!K1fQcC#`smu{J0001Z+GAi~Fo41=h6RibOa;t(%zs#9 zSfW_wu{>f`V~t_0U|qm^iA{|yh3yi13i~+@CyryBdYo^#O1M^Ved2cDPT}6fQ@|_5 zJC9FYApB3HMpQ^NP4t+UhS&k|DDiU= z1`=@+eG+>lStR8o9VGWjX-G9meUXlmJ|VM6RzNmFc7vRmT#h`8e3AS<1q+2~3jY*m zD1K53Q`(^%p!`auLgk+76xA(iDQd6OCjj9o4G)byn(MUEv?geGXz$R;(|M;WplhQW zp=YNTrMF3+O~1{6$w0}V!{Cu2o1ur{6vIbGY(@)=eM~G&?wMwoelcq^Pq5&!xMkU5 zC1o|wTFrWwjhD?Nn>)5zwk@`A>~`2o*jLy;bC~4F;ke8x$LW@{hw}j!8<%~qDsD_} zd~Q;1YHmhuc5YtoJnjO8tUrg<##Sm&|JGVVt7t$2<>gT3%{ci->PC%OLVpGeJZs|>sotf{x{V;qxq@N%rBICom6?t{qi@Z zSXTaM$+==AT31QJOinG{k*l~0y@xQFqUzQ zX95$M#AK#0m1#_81~Zw(Z00bRdCaGr3b9B8$Jxp@ZgP+>Y^RAm9O48mVr4fU*}?&d zlqmLzjh)=#vqW>4llui!9&(>ERI-3(s(4H_4|v3Lp74}se5Hn0yx=8gspS{@ zdCP0wP{+6M4|lPU0E<|{V(K|U1It)SkVZl*X9X*1Wff~!&05y8j%yrcBOBPnX1?>2 z>%8L}=efaqKJh_f#4fQCC-IUXiIODAk|L>+Ch3yF1uk-htK8)hm$}CdPDv)WxGh&(xG%JUCJV5vC^$e;*92-q!Ro4t#yWFl_)T4Yt1lF6Xd8Sghu>@F2x}-EO6Na;hnz3C0sn=t0gV7l zun16Cu>k>&S+Pb2D_9}05LrvG6jE3ruz*<|um&q!SOBmEAVshPD?|aX1|UVS11m&X zuoNqJ+GAi8VBmc7hk=2CbN;^o1_t(iAd`^+8N31jc{T-l0001Z+Le>N62c%1fKjNz zqj(Mu&fPjY_APvXK7g}(7hb{hEtoy0K7*Y*N)nJ1%bn8uE=Lm5{D85Q6Mkty%lN&q zn|+Xtmm>kX2-wuw*wxP1^_?W@#|#%3ne?bS@Gw?(B#UQCdsnc(e)G@kf!d*7)sk)| znLY>fC8{HdVz!vjYH#U!~hjO6a12~^BE8a`Y8{$2^Ur+J*c|I%f+g=z4 zkM>;Ce`j|6y$3%$w-86^a*TM_II-T1OZ}YL-NOEq>dxapUy3o}ovuSKTFMP=SiAUR mrMZ0Q)2!oL0mMZA5)+++naCl$L(E%ucvl+w-Y;MXp#T8OH63mM diff --git a/resources/LuxiMono-RegularOblique.woff b/resources/LuxiMono-RegularOblique.woff deleted file mode 100644 index 26999f990fa9f9302762b55318c27d4d24f26bf8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 29300 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 diff --git a/resources/ScalaReference.js b/resources/ScalaReference.js deleted file mode 100644 index 51be0cf05b38..000000000000 --- a/resources/ScalaReference.js +++ /dev/null @@ -1,20 +0,0 @@ -$(function() { - - var popoutTOC = $('

'); - popoutTOC.attr('id', 'popoutTOC'); - - var popoutTOChead = $('Jump to...'); - popoutTOChead.appendTo(popoutTOC); - - var content = $('
'); - $('#TOC > *').clone().appendTo(content); - content.appendTo(popoutTOC); - var enter = function() { content.css('display', 'block') }; - var exit = function() { content.css('display', 'none') }; - - popoutTOC.hover(enter, exit); - - // disabled for now, until better styled - // popoutTOC.appendTo($('body')); - -}) \ No newline at end of file diff --git a/resources/blueprint-print.css b/resources/blueprint-print.css deleted file mode 100755 index d3a905512030..000000000000 --- a/resources/blueprint-print.css +++ /dev/null @@ -1,29 +0,0 @@ -/* ----------------------------------------------------------------------- - - - Blueprint CSS Framework 1.0.1 - http://blueprintcss.org - - * Copyright (c) 2007-Present. See LICENSE for more info. - * See README for instructions on how to use Blueprint. - * For credits and origins, see AUTHORS. - * This is a compressed file. See the sources in the 'src' directory. - ------------------------------------------------------------------------ */ - -/* print.css */ -body {line-height:1.5;font-family:Heuristica,Georgia,serif;color:#000;background:none;font-size:10pt;} -.container {background:none;} -hr {background:#ccc;color:#ccc;width:100%;height:2px;margin:2em 0;padding:0;border:none;} -hr.space {background:#fff;color:#fff;visibility:hidden;} -h1, h2, h3, h4, h5, h6 {font-family:Heuristica,Georgia,serif;} -code {font:.9em "Luxi Mono", "Courier New", Monaco, Courier, monospace;} -a img {border:none;} -p img.top {margin-top:0;} -blockquote {margin:1.5em;padding:1em;font-style:italic;font-size:.9em;} -.small {font-size:.9em;} -.large {font-size:1.1em;} -.quiet {color:#999;} -.hide {display:none;} -a:link, a:visited {background:transparent;font-weight:700;text-decoration:underline;} -a:link:after, a:visited:after {content:" (" attr(href) ")";font-size:90%;} diff --git a/resources/blueprint-screen.css b/resources/blueprint-screen.css deleted file mode 100644 index 2e3600079fdd..000000000000 --- a/resources/blueprint-screen.css +++ /dev/null @@ -1,231 +0,0 @@ -/* ----------------------------------------------------------------------- - - - Blueprint CSS Framework 1.0.1 - http://blueprintcss.org - - * Copyright (c) 2007-Present. See LICENSE for more info. - * See README for instructions on how to use Blueprint. - * For credits and origins, see AUTHORS. - * This is a compressed file. See the sources in the 'src' directory. - ------------------------------------------------------------------------ */ - -/* reset.css */ -html {margin:0;padding:0;border:0;} -body, div, span, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, code, del, dfn, em, img, q, dl, dt, dd, ol, ul, li, fieldset, form, label, legend, table, caption, tbody, tfoot, thead, tr, th, td, article, aside, dialog, figure, footer, header, hgroup, nav, section {margin:0;padding:0;border:0;font-size:100%;font:inherit;vertical-align:baseline;} -article, aside, details, figcaption, figure, dialog, footer, header, hgroup, menu, nav, section {display:block;} -body {line-height:1.5;background:white;} -table {border-collapse:separate;border-spacing:0;} -caption, th, td {text-align:left;font-weight:normal;float:none !important;} -table, th, td {vertical-align:middle;} -blockquote:before, blockquote:after, q:before, q:after {content:'';} -blockquote, q {quotes:"" "";} -a img {border:none;} -:focus {outline:0;} - -/* typography.css */ -html {font-size:100.01%;} -body {color:#222;background:#fff;font-family:Heuristica,Georgia,serif;} -h1, h2, h3, h4, h5, h6 {font-weight:normal;color:#111;} -h1 {font-size:3em;line-height:1;margin-top:1em;margin-bottom:0.5em;} -h2 {font-size:2em;margin-bottom:0.75em;} -h3 {font-size:1.5em;line-height:1;margin-bottom:1em;} -h4 {font-size:1.2em;line-height:1.25;margin-bottom:1.25em;} -h5 {font-size:1em;font-weight:bold;margin-bottom:1.5em;} -h6 {font-size:1em;font-weight:bold;} -h1 img, h2 img, h3 img, h4 img, h5 img, h6 img {margin:0;} -p {margin:0 0 0.5em;} -.left {float:left !important;} -p .left {margin:0.5em 0.5em 0.5em 0;padding:0;} -.right {float:right !important;} -p .right {margin:0.5em 0 0.5em 0.5em;padding:0;} -a:focus, a:hover {color:#09f;text-decoration:underline;} -a {color:#06c;text-decoration:none;} -blockquote {margin:1.5em;color:#666;font-style:italic;} -strong, dfn {font-weight:bold;} -em, dfn {font-style:italic;} -sup, sub {line-height:0;} -abbr, acronym {border-bottom:1px dotted #666;} -address {margin:0 0 1.5em;font-style:italic;} -del {color:#666;} -pre {margin:1.5em 0;white-space:pre;} -pre, code, tt {font:90% "Luxi Mono", 'andale mono', 'lucida console', monospace;line-height:1.5;} -li ul, li ol {margin:0;} -ul, ol {margin:0 1.5em 1.5em 0;padding-left:1.5em;} -ul {list-style-type:disc;} -ol {list-style-type:decimal;} -dl {margin:0 0 1.5em 0;} -dl dt {font-weight:bold;} -dd {margin-left:1.5em;} -table {margin-bottom:1.4em;width:100%;} -th {font-weight:bold;} -thead th {background:#c3d9ff;} -th, td, caption {padding:4px 10px 4px 5px;} -tbody tr:nth-child(even) td, tbody tr.even td {background:#e5ecf9;} -tfoot {font-style:italic;} -caption {background:#eee;} -.small {font-size:.8em;margin-bottom:1.875em;line-height:1.875em;} -.large {font-size:1.2em;line-height:2.5em;margin-bottom:1.25em;} -.hide {display:none;} -.quiet {color:#666;} -.loud {color:#000;} -.highlight {background:#ff0;} -.added {background:#060;color:#fff;} -.removed {background:#900;color:#fff;} -.first {margin-left:0;padding-left:0;} -.last {margin-right:0;padding-right:0;} -.top {margin-top:0;padding-top:0;} -.bottom {margin-bottom:0;padding-bottom:0;} - -/* forms.css */ -label {font-weight:bold;} -fieldset {padding:0 1.4em 1.4em 1.4em;margin:0 0 1.5em 0;border:1px solid #ccc;} -legend {font-weight:bold;font-size:1.2em;margin-top:-0.2em;margin-bottom:1em;} -fieldset, #IE8#HACK {padding-top:1.4em;} -legend, #IE8#HACK {margin-top:0;margin-bottom:0;} -input[type=text], input[type=password], input[type=url], input[type=email], input.text, input.title, textarea {background-color:#fff;border:1px solid #bbb;color:#000;} -input[type=text]:focus, input[type=password]:focus, input[type=url]:focus, input[type=email]:focus, input.text:focus, input.title:focus, textarea:focus {border-color:#666;} -select {background-color:#fff;border-width:1px;border-style:solid;} -input[type=text], input[type=password], input[type=url], input[type=email], input.text, input.title, textarea, select {margin:0.5em 0;} -input.text, input.title {width:300px;padding:5px;} -input.title {font-size:1.5em;} -textarea {width:390px;height:250px;padding:5px;} -form.inline {line-height:3;} -form.inline p {margin-bottom:0;} -.error, .alert, .notice, .success, .info {padding:0.8em;margin-bottom:1em;border:2px solid #ddd;} -.error, .alert {background:#fbe3e4;color:#8a1f11;border-color:#fbc2c4;} -.notice {background:#fff6bf;color:#514721;border-color:#ffd324;} -.success {background:#e6efc2;color:#264409;border-color:#c6d880;} -.info {background:#d5edf8;color:#205791;border-color:#92cae4;} -.error a, .alert a {color:#8a1f11;} -.notice a {color:#514721;} -.success a {color:#264409;} -.info a {color:#205791;} - -/* grid.css */ -.container {width:710px;margin:0 auto;} -.showgrid {background:url(grid.png);} -.column, .span-1, .span-2, .span-3, .span-4, .span-5, .span-6, .span-7, .span-8, .span-9, .span-10, .span-11, .span-12, .span-13, .span-14, .span-15, .span-16, .span-17, .span-18 {float:left;margin-right:10px;} -.last {margin-right:0;} -.span-1 {width:30px;} -.span-2 {width:70px;} -.span-3 {width:110px;} -.span-4 {width:150px;} -.span-5 {width:190px;} -.span-6 {width:230px;} -.span-7 {width:270px;} -.span-8 {width:310px;} -.span-9 {width:350px;} -.span-10 {width:390px;} -.span-11 {width:430px;} -.span-12 {width:470px;} -.span-13 {width:510px;} -.span-14 {width:550px;} -.span-15 {width:590px;} -.span-16 {width:630px;} -.span-17 {width:670px;} -.span-18 {width:710px;margin-right:0;} -input.span-1, textarea.span-1, input.span-2, textarea.span-2, input.span-3, textarea.span-3, input.span-4, textarea.span-4, input.span-5, textarea.span-5, input.span-6, textarea.span-6, input.span-7, textarea.span-7, input.span-8, textarea.span-8, input.span-9, textarea.span-9, input.span-10, textarea.span-10, input.span-11, textarea.span-11, input.span-12, textarea.span-12, input.span-13, textarea.span-13, input.span-14, textarea.span-14, input.span-15, textarea.span-15, input.span-16, textarea.span-16, input.span-17, textarea.span-17, input.span-18, textarea.span-18 {border-left-width:1px;border-right-width:1px;padding-left:5px;padding-right:5px;} -input.span-1, textarea.span-1 {width:18px;} -input.span-2, textarea.span-2 {width:58px;} -input.span-3, textarea.span-3 {width:98px;} -input.span-4, textarea.span-4 {width:138px;} -input.span-5, textarea.span-5 {width:178px;} -input.span-6, textarea.span-6 {width:218px;} -input.span-7, textarea.span-7 {width:258px;} -input.span-8, textarea.span-8 {width:298px;} -input.span-9, textarea.span-9 {width:338px;} -input.span-10, textarea.span-10 {width:378px;} -input.span-11, textarea.span-11 {width:418px;} -input.span-12, textarea.span-12 {width:458px;} -input.span-13, textarea.span-13 {width:498px;} -input.span-14, textarea.span-14 {width:538px;} -input.span-15, textarea.span-15 {width:578px;} -input.span-16, textarea.span-16 {width:618px;} -input.span-17, textarea.span-17 {width:658px;} -input.span-18, textarea.span-18 {width:698px;} -.append-1 {padding-right:40px;} -.append-2 {padding-right:80px;} -.append-3 {padding-right:120px;} -.append-4 {padding-right:160px;} -.append-5 {padding-right:200px;} -.append-6 {padding-right:240px;} -.append-7 {padding-right:280px;} -.append-8 {padding-right:320px;} -.append-9 {padding-right:360px;} -.append-10 {padding-right:400px;} -.append-11 {padding-right:440px;} -.append-12 {padding-right:480px;} -.append-13 {padding-right:520px;} -.append-14 {padding-right:560px;} -.append-15 {padding-right:600px;} -.append-16 {padding-right:640px;} -.append-17 {padding-right:680px;} -.append-18 {padding-right:720px;} -.prepend-1 {padding-left:40px;} -.prepend-2 {padding-left:80px;} -.prepend-3 {padding-left:120px;} -.prepend-4 {padding-left:160px;} -.prepend-5 {padding-left:200px;} -.prepend-6 {padding-left:240px;} -.prepend-7 {padding-left:280px;} -.prepend-8 {padding-left:320px;} -.prepend-9 {padding-left:360px;} -.prepend-10 {padding-left:400px;} -.prepend-11 {padding-left:440px;} -.prepend-12 {padding-left:480px;} -.prepend-13 {padding-left:520px;} -.prepend-14 {padding-left:560px;} -.prepend-15 {padding-left:600px;} -.prepend-16 {padding-left:640px;} -.prepend-17 {padding-left:680px;} -.prepend-18 {padding-left:720px;} -.border {padding-right:4px;margin-right:5px;border-right:1px solid #ddd;} -.colborder {padding-right:24px;margin-right:25px;border-right:1px solid #ddd;} -.pull-1 {margin-left:-40px;} -.pull-2 {margin-left:-80px;} -.pull-3 {margin-left:-120px;} -.pull-4 {margin-left:-160px;} -.pull-5 {margin-left:-200px;} -.pull-6 {margin-left:-240px;} -.pull-7 {margin-left:-280px;} -.pull-8 {margin-left:-320px;} -.pull-9 {margin-left:-360px;} -.pull-10 {margin-left:-400px;} -.pull-11 {margin-left:-440px;} -.pull-12 {margin-left:-480px;} -.pull-13 {margin-left:-520px;} -.pull-14 {margin-left:-560px;} -.pull-15 {margin-left:-600px;} -.pull-16 {margin-left:-640px;} -.pull-17 {margin-left:-680px;} -.pull-18 {margin-left:-720px;} -.pull-1, .pull-2, .pull-3, .pull-4, .pull-5, .pull-6, .pull-7, .pull-8, .pull-9, .pull-10, .pull-11, .pull-12, .pull-13, .pull-14, .pull-15, .pull-16, .pull-17, .pull-18 {float:left;position:relative;} -.push-1 {margin:0 -40px 1.5em 40px;} -.push-2 {margin:0 -80px 1.5em 80px;} -.push-3 {margin:0 -120px 1.5em 120px;} -.push-4 {margin:0 -160px 1.5em 160px;} -.push-5 {margin:0 -200px 1.5em 200px;} -.push-6 {margin:0 -240px 1.5em 240px;} -.push-7 {margin:0 -280px 1.5em 280px;} -.push-8 {margin:0 -320px 1.5em 320px;} -.push-9 {margin:0 -360px 1.5em 360px;} -.push-10 {margin:0 -400px 1.5em 400px;} -.push-11 {margin:0 -440px 1.5em 440px;} -.push-12 {margin:0 -480px 1.5em 480px;} -.push-13 {margin:0 -520px 1.5em 520px;} -.push-14 {margin:0 -560px 1.5em 560px;} -.push-15 {margin:0 -600px 1.5em 600px;} -.push-16 {margin:0 -640px 1.5em 640px;} -.push-17 {margin:0 -680px 1.5em 680px;} -.push-18 {margin:0 -720px 1.5em 720px;} -.push-1, .push-2, .push-3, .push-4, .push-5, .push-6, .push-7, .push-8, .push-9, .push-10, .push-11, .push-12, .push-13, .push-14, .push-15, .push-16, .push-17, .push-18 {float:left;position:relative;} -div.prepend-top, .prepend-top {margin-top:1.5em;} -div.append-bottom, .append-bottom {margin-bottom:1.5em;} -.box {padding:1.5em;margin-bottom:1.5em;background:#e5eCf9;} -hr {background:#ddd;color:#ddd;clear:both;float:none;width:100%;height:1px;margin:0 0 17px;border:none;} -hr.space {background:#fff;color:#fff;visibility:hidden;} -.clearfix:after, .container:after {content:"\0020";display:block;height:0;clear:both;visibility:hidden;overflow:hidden;} -.clearfix, .container {display:block;} -.clear {clear:both;} diff --git a/resources/fonts.css b/resources/fonts.css deleted file mode 100644 index a47d453f295e..000000000000 --- a/resources/fonts.css +++ /dev/null @@ -1,57 +0,0 @@ -@font-face { - font-family: 'Luxi Mono'; - src: local('Luxi Mono Regular'), - url('LuxiMono-Regular.woff') format('woff'); - font-weight: normal; - font-style: normal; -} -@font-face { - font-family: 'Luxi Mono'; - src: local('Luxi Mono Oblique'), - url('LuxiMono-BoldOblique.woff') format('woff'); - font-weight: normal; - font-style: oblique; -} -@font-face { - font-family: 'Luxi Mono'; - src: local('Luxi Mono Bold'), - url('LuxiMono-Bold.woff') format('woff'); - font-weight: bold; - font-style: normal; -} -@font-face { - font-family: 'Luxi Mono'; - src: local('Luxi Mono Bold Oblique'), - url('LuxiMono-BoldOblique.woff') format('woff'); - font-weight: bold; - font-style: oblique; -} - -@font-face { - font-family: 'Heuristica'; - src: local('Heuristica Regular'), - url('Heuristica-Regular.woff') format('woff'); - font-weight: normal; - font-style: normal; -} -@font-face { - font-family: 'Heuristica'; - src: local('Heuristica Italic'), - url('Heuristica-RegularItalic.woff') format('woff'); - font-weight: normal; - font-style: italic; -} -@font-face { - font-family: 'Heuristica'; - src: local('Heuristica Bold'), - url('Heuristica-Bold.woff') format('woff'); - font-weight: bold; - font-style: normal; -} -@font-face { - font-family: 'Heuristica'; - src: local('Heuristica Bold Italic'), - url('Heuristica-BoldItalic.woff') format('woff'); - font-weight: bold; - font-style: italic; -} diff --git a/resources/grid.png b/resources/grid.png deleted file mode 100755 index 4ceb11042608204d733ab76868b062f9cc0c76b2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 104 zcmeAS@N?(olHy`uVBq!ia0vp^8bB<>#0(@u3QJ6Z6lZ`>i0g~@zhAz5`Tzg_MyHUO zKtU-_7srr_Imt;44C_Ky&yaYKkYV7gc%b@g7K2I&YxzWL#ay5&22WQ%mvv4FO#siN BAS?g? diff --git a/resources/ie.css b/resources/ie.css deleted file mode 100755 index f01539959a41..000000000000 --- a/resources/ie.css +++ /dev/null @@ -1,36 +0,0 @@ -/* ----------------------------------------------------------------------- - - - Blueprint CSS Framework 1.0.1 - http://blueprintcss.org - - * Copyright (c) 2007-Present. See LICENSE for more info. - * See README for instructions on how to use Blueprint. - * For credits and origins, see AUTHORS. - * This is a compressed file. See the sources in the 'src' directory. - ------------------------------------------------------------------------ */ - -/* ie.css */ -body {text-align:center;} -.container {text-align:left;} -* html .column, * html .span-1, * html .span-2, * html .span-3, * html .span-4, * html .span-5, * html .span-6, * html .span-7, * html .span-8, * html .span-9, * html .span-10, * html .span-11, * html .span-12, * html .span-13, * html .span-14, * html .span-15, * html .span-16, * html .span-17, * html .span-18, * html .span-19, * html .span-20, * html .span-21, * html .span-22, * html .span-23, * html .span-24 {display:inline;overflow-x:hidden;} -* html legend {margin:0px -8px 16px 0;padding:0;} -sup {vertical-align:text-top;} -sub {vertical-align:text-bottom;} -html>body p code {*white-space:normal;} -hr {margin:-8px auto 11px;} -img {-ms-interpolation-mode:bicubic;} -.clearfix, .container {display:inline-block;} -* html .clearfix, * html .container {height:1%;} -fieldset {padding-top:0;} -legend {margin-top:-0.2em;margin-bottom:1em;margin-left:-0.5em;} -textarea {overflow:auto;} -label {vertical-align:middle;position:relative;top:-0.25em;} -input.text, input.title, textarea {background-color:#fff;border:1px solid #bbb;} -input.text:focus, input.title:focus {border-color:#666;} -input.text, input.title, textarea, select {margin:0.5em 0;} -input.checkbox, input.radio {position:relative;top:.25em;} -form.inline div, form.inline p {vertical-align:middle;} -form.inline input.checkbox, form.inline input.radio, form.inline input.button, form.inline button {margin:0.5em 0;} -button, input.button {position:relative;top:0.25em;} \ No newline at end of file diff --git a/resources/scala-ref-template.html5 b/resources/scala-ref-template.html5 deleted file mode 100644 index 2ff8991df1fc..000000000000 --- a/resources/scala-ref-template.html5 +++ /dev/null @@ -1,81 +0,0 @@ - - - - - -$for(author-meta)$ - -$endfor$ -$if(date-meta)$ - -$endif$ - $if(title-prefix)$$title-prefix$ - $endif$$if(pagetitle)$$pagetitle$$endif$ - -$if(quotes)$ - -$endif$ -$if(highlighting-css)$ - -$endif$ -$for(css)$ - -$endfor$ - - - -$if(math)$ - $math$ -$endif$ -$for(header-includes)$ - $header-includes$ -$endfor$ - - - - - - - - - -
-$for(include-before)$ -$include-before$ -$endfor$ -$if(title)$ -
-

$title$

-$if(date)$ -

$date$

-$endif$ -
-
-$endif$ -$if(toc)$ - -$endif$ -$body$ -$for(include-after)$ -$include-after$ -$endfor$ -
- - diff --git a/resources/scala-ref-template.latex b/resources/scala-ref-template.latex deleted file mode 100644 index 077a0dc2a058..000000000000 --- a/resources/scala-ref-template.latex +++ /dev/null @@ -1,164 +0,0 @@ -\documentclass[$if(fontsize)$$fontsize$,$endif$$if(lang)$$lang$,$endif$$if(papersize)$$papersize$,$endif$]{$documentclass$} - -\usepackage{mathrsfs} -\usepackage{amssymb,amsmath} -\usepackage{ifxetex,ifluatex} -\usepackage{fixltx2e} % provides \textsubscript -% use microtype if available -\IfFileExists{microtype.sty}{\usepackage{microtype}}{} -% use upquote if available, for straight quotes in verbatim environments -\IfFileExists{upquote.sty}{\usepackage{upquote}}{} -\ifnum 0\ifxetex 1\fi\ifluatex 1\fi=0 % if pdftex - \usepackage[utf8]{inputenc} -$if(euro)$ - \usepackage{eurosym} -$endif$ -\else % if luatex or xelatex - \usepackage{fontspec} - \ifxetex - \usepackage{xltxtra,xunicode} - \fi - \defaultfontfeatures{Mapping=tex-text,Scale=MatchLowercase} - \newcommand{\euro}{€} - \setmainfont{Heuristica Regular} - \setmonofont[Scale=0.8]{Luxi Mono} -$if(sansfont)$ - \setsansfont{$sansfont$} -$endif$ -$if(mathfont)$ - \setmathfont{$mathfont$} -$endif$ -\fi -$if(geometry)$ -\usepackage[$for(geometry)$$geometry$$sep$,$endfor$]{geometry} -$endif$ -$if(natbib)$ -\usepackage{natbib} -\bibliographystyle{plainnat} -$endif$ -$if(biblatex)$ -\usepackage{biblatex} -$if(biblio-files)$ -\bibliography{$biblio-files$} -$endif$ -$endif$ -$if(listings)$ -\usepackage{listings} -$endif$ -$if(lhs)$ -\lstnewenvironment{code}{\lstset{language=Haskell,basicstyle=\small\ttfamily}}{} -$endif$ -$if(highlighting-macros)$ -$highlighting-macros$ -$endif$ -$if(verbatim-in-note)$ -\usepackage{fancyvrb} -$endif$ -$if(tables)$ -\usepackage{longtable} -$endif$ -$if(graphics)$ -\usepackage{graphicx} -% We will generate all images so they have a width \maxwidth. This means -% that they will get their normal width if they fit onto the page, but -% are scaled down if they would overflow the margins. -\makeatletter -\def\maxwidth{\ifdim\Gin@nat@width>\linewidth\linewidth -\else\Gin@nat@width\fi} -\makeatother -\let\Oldincludegraphics\includegraphics -\renewcommand{\includegraphics}[1]{\Oldincludegraphics[width=\maxwidth]{#1}} -$endif$ -\ifxetex - \usepackage[setpagesize=false, % page size defined by xetex - unicode=false, % unicode breaks when used with xetex - xetex]{hyperref} -\else - \usepackage[unicode=true]{hyperref} -\fi -\hypersetup{breaklinks=true, - bookmarks=true, - pdfauthor={$author-meta$}, - pdftitle={$title-meta$}, - colorlinks=true, - urlcolor=$if(urlcolor)$$urlcolor$$else$blue$endif$, - linkcolor=$if(linkcolor)$$linkcolor$$else$magenta$endif$, - pdfborder={0 0 0}} -\urlstyle{same} % don't use monospace font for urls -$if(links-as-notes)$ -% Make links footnotes instead of hotlinks: -\renewcommand{\href}[2]{#2\footnote{\url{#1}}} -$endif$ -$if(strikeout)$ -\usepackage[normalem]{ulem} -% avoid problems with \sout in headers with hyperref: -\pdfstringdefDisableCommands{\renewcommand{\sout}{}} -$endif$ -\setlength{\parindent}{0pt} -\setlength{\parskip}{6pt plus 2pt minus 1pt} -\setlength{\emergencystretch}{3em} % prevent overfull lines -$if(numbersections)$ -$else$ -\setcounter{secnumdepth}{0} -$endif$ -$if(verbatim-in-note)$ -\VerbatimFootnotes % allows verbatim text in footnotes -$endif$ -$if(lang)$ -\ifxetex - \usepackage{polyglossia} - \setmainlanguage{$mainlang$} -\else - \usepackage[$lang$]{babel} -\fi -$endif$ -$for(header-includes)$ -$header-includes$ -$endfor$ - -$if(title)$ -\title{$title$} -$endif$ -%\author{$for(author)$$author$$sep$ \and $endfor$} -\date{$date$} - -\begin{document} -$if(title)$ -\maketitle -$endif$ - -$for(include-before)$ -$include-before$ - -$endfor$ -$if(toc)$ -{ -\hypersetup{linkcolor=black} -\setcounter{tocdepth}{$toc-depth$} -\tableofcontents -} -$endif$ -$body$ - -$if(natbib)$ -$if(biblio-files)$ -$if(biblio-title)$ -$if(book-class)$ -\renewcommand\bibname{$biblio-title$} -$else$ -\renewcommand\refname{$biblio-title$} -$endif$ -$endif$ -\bibliography{$biblio-files$} - -$endif$ -$endif$ -$if(biblatex)$ -\printbibliography$if(biblio-title)$[title=$biblio-title$]$endif$ - -$endif$ -$for(include-after)$ -$include-after$ - -$endfor$ -\end{document} diff --git a/resources/style.css b/resources/style.css deleted file mode 100644 index 17d13741a790..000000000000 --- a/resources/style.css +++ /dev/null @@ -1,93 +0,0 @@ -header h1 { - text-align: center; -} - -header .date { - text-align: center; -} - -nav ul { - list-style-type: none; -} - -.container > h1 a, -.container > h2 a, -.container > h3 a, -.container > h4 a, -.container > h5 a, -.container > h6 a { - text-decoration: none; - color: #111; -} - -p { - -moz-font-feature-settings: "onum"; - -ms-font-feature-settings: "onum"; - -webkit-font-feature-settings: "onum"; - font-feature-settings: "onum"; -} - -pre { - margin-left: 1em; - margin-right: 1em; - padding: 1em; - background-color: #EEE; -} - -pre.math { - margin: 0; - padding: 0; - background-color: transparent; - border: 0; -} - -pre[class="grammar"]:before { - content: "Syntax\A"; - font-family: Heuristica; - font-size:110%; - font-weight:bold; -} - -code > span { - font-weight: normal !important; -} - -code { - padding-left: 0.1em; - padding-right: 0.1em; -} - -/* examples */ -ol[type="1"] { - list-style-type: none; - margin-left: 1em; - margin-right: 1em; - padding: 0; -} - -ol[type="1"] > li { - margin-top: 1em; - padding: 1em; - background-color: #E5ECF9; -} - -ol[type="1"] > li:before { - content: "Example"; - font-weight:bold; -} - -#popoutTOC { - position: fixed; - top: 0; - left: 0; - margin: 0; - padding: 0; -} - -#popoutTOC .head { - -} - -#popoutTOC .links { - display: none; -} diff --git a/01-title.md b/spec/01-title.md similarity index 100% rename from 01-title.md rename to spec/01-title.md diff --git a/02-preface.md b/spec/02-preface.md similarity index 100% rename from 02-preface.md rename to spec/02-preface.md diff --git a/03-lexical-syntax.md b/spec/03-lexical-syntax.md similarity index 100% rename from 03-lexical-syntax.md rename to spec/03-lexical-syntax.md diff --git a/04-identifiers-names-and-scopes.md b/spec/04-identifiers-names-and-scopes.md similarity index 100% rename from 04-identifiers-names-and-scopes.md rename to spec/04-identifiers-names-and-scopes.md diff --git a/05-types.md b/spec/05-types.md similarity index 100% rename from 05-types.md rename to spec/05-types.md diff --git a/06-basic-declarations-and-definitions.md b/spec/06-basic-declarations-and-definitions.md similarity index 100% rename from 06-basic-declarations-and-definitions.md rename to spec/06-basic-declarations-and-definitions.md diff --git a/07-classes-and-objects.md b/spec/07-classes-and-objects.md similarity index 100% rename from 07-classes-and-objects.md rename to spec/07-classes-and-objects.md diff --git a/08-expressions.md b/spec/08-expressions.md similarity index 100% rename from 08-expressions.md rename to spec/08-expressions.md diff --git a/09-implicit-parameters-and-views.md b/spec/09-implicit-parameters-and-views.md similarity index 100% rename from 09-implicit-parameters-and-views.md rename to spec/09-implicit-parameters-and-views.md diff --git a/10-pattern-matching.md b/spec/10-pattern-matching.md similarity index 100% rename from 10-pattern-matching.md rename to spec/10-pattern-matching.md diff --git a/11-top-level-definitions.md b/spec/11-top-level-definitions.md similarity index 100% rename from 11-top-level-definitions.md rename to spec/11-top-level-definitions.md diff --git a/12-xml-expressions-and-patterns.md b/spec/12-xml-expressions-and-patterns.md similarity index 100% rename from 12-xml-expressions-and-patterns.md rename to spec/12-xml-expressions-and-patterns.md diff --git a/13-user-defined-annotations.md b/spec/13-user-defined-annotations.md similarity index 100% rename from 13-user-defined-annotations.md rename to spec/13-user-defined-annotations.md diff --git a/14-the-scala-standard-library.md b/spec/14-the-scala-standard-library.md similarity index 99% rename from 14-the-scala-standard-library.md rename to spec/14-the-scala-standard-library.md index d0d06c25b2b3..4b79fd328514 100644 --- a/14-the-scala-standard-library.md +++ b/spec/14-the-scala-standard-library.md @@ -10,7 +10,7 @@ The Scala standard library consists of the package `scala` with a number of classes and modules. Some of these classes are described in the following. -![Class hierarchy of Scala](resources/classhierarchy.pdf) +![Class hierarchy of Scala](public/images/classhierarchy.pdf) ## Root Classes diff --git a/15-syntax-summary.md b/spec/15-syntax-summary.md similarity index 100% rename from 15-syntax-summary.md rename to spec/15-syntax-summary.md diff --git a/Scala.bib b/spec/16-references.md similarity index 85% rename from Scala.bib rename to spec/16-references.md index cb91c4641878..3535a384fb77 100644 --- a/Scala.bib +++ b/spec/16-references.md @@ -1,16 +1,26 @@ +--- +title: References +layout: default +chapter: 14 +--- + + +# References + + \ No newline at end of file diff --git a/README.md b/spec/README.md similarity index 100% rename from README.md rename to spec/README.md diff --git a/_config.yml b/spec/_config.yml similarity index 95% rename from _config.yml rename to spec/_config.yml index 906ded51f5b7..2867e48a110f 100644 --- a/_config.yml +++ b/spec/_config.yml @@ -1,6 +1,6 @@ safe: true lsi: false -highlighter: pygments +highlighter: null markdown: redcarpet encoding: utf-8 redcarpet: diff --git a/_includes/numbering.css b/spec/_includes/numbering.css similarity index 100% rename from _includes/numbering.css rename to spec/_includes/numbering.css diff --git a/_layouts/default.yml b/spec/_layouts/default.yml similarity index 88% rename from _layouts/default.yml rename to spec/_layouts/default.yml index 814bc511a9c4..7f17ba30b020 100644 --- a/_layouts/default.yml +++ b/spec/_layouts/default.yml @@ -24,8 +24,7 @@ $( document ).ready(function(){ $("h3[id*='example']").text("") }) - - + diff --git a/index.md b/spec/index.md similarity index 100% rename from index.md rename to spec/index.md diff --git a/resources/classhierarchy.pdf b/spec/public/images/classhierarchy.pdf similarity index 100% rename from resources/classhierarchy.pdf rename to spec/public/images/classhierarchy.pdf diff --git a/resources/github.css b/spec/public/stylesheets/screen.css similarity index 96% rename from resources/github.css rename to spec/public/stylesheets/screen.css index bf8df4bb0307..863591ed7728 100644 --- a/resources/github.css +++ b/spec/public/stylesheets/screen.css @@ -1,3 +1,5 @@ +/* from https://gist.github.com/andyferra/2554919 */ + body { font-family: Helvetica, arial, sans-serif; font-size: 14px; @@ -100,9 +102,11 @@ h6 { p, blockquote, ul, ol, dl, li, table, pre { margin: 15px 0; + -moz-font-feature-settings: "onum"; + -ms-font-feature-settings: "onum"; + -webkit-font-feature-settings: "onum"; + font-feature-settings: "onum"; } - - hr { background: transparent url("../../images/modules/pulls/dirty-shade.png") repeat-x 0 0; diff --git a/test.html b/test.html deleted file mode 100644 index 37a5b3d86553..000000000000 --- a/test.html +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - private def omg(x : Int) : Int = x - - \ No newline at end of file From b102ffc9e8a57e0ae3deac287fbd32d8beff46f0 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 27 Mar 2014 18:19:29 -0700 Subject: [PATCH 165/826] Disable strict host checking --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 0bd7db1f6296..b171ce67a664 100644 --- a/.travis.yml +++ b/.travis.yml @@ -18,4 +18,4 @@ after_success: - ssh-add -D - chmod 600 spec/id_dsa_travis - ssh-add spec/id_dsa_travis - - rsync -rzv build/spec/ scalatest@chara.epfl.ch:/home/linuxsoft/archives/scala/spec/2.11/ \ No newline at end of file + - rsync -e 'ssh -o StrictHostKeyChecking=no' -rzv build/spec/ scalatest@chara.epfl.ch:/home/linuxsoft/archives/scala/spec/2.11/ \ No newline at end of file From 3560ddc9eac300bf9a88924e8c2caad5be07bfd5 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 27 Mar 2014 18:22:40 -0700 Subject: [PATCH 166/826] Start ssh-agent --- .travis.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index b171ce67a664..2bad98528e61 100644 --- a/.travis.yml +++ b/.travis.yml @@ -15,7 +15,8 @@ env: # the key is restricted using forced commands so that it can only upload to the directory we need here after_success: - openssl aes-256-cbc -pass "pass:$PRIV_KEY_SECRET" -in spec/id_dsa_travis.enc -out spec/id_dsa_travis -d -a - - ssh-add -D - chmod 600 spec/id_dsa_travis + - eval "$(ssh-agent)" + - ssh-add -D - ssh-add spec/id_dsa_travis - rsync -e 'ssh -o StrictHostKeyChecking=no' -rzv build/spec/ scalatest@chara.epfl.ch:/home/linuxsoft/archives/scala/spec/2.11/ \ No newline at end of file From 12720e699dce034bf54dedb556bf7611e6e1f474 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Fri, 28 Mar 2014 10:13:58 -0700 Subject: [PATCH 167/826] Remove scala-continuations-plugin from scala-library-all The continuations plugin should instead be a dependency of scala-dist, as scala-library-all should be a drop-in replacement for scala-library, and as such should not (indirectly) depend on plugins/the compiler. --- src/build/maven/scala-dist-pom.xml | 5 +++++ src/build/maven/scala-library-all-pom.xml | 10 +++++----- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/src/build/maven/scala-dist-pom.xml b/src/build/maven/scala-dist-pom.xml index 9a566d231bef..83ebc263c033 100644 --- a/src/build/maven/scala-dist-pom.xml +++ b/src/build/maven/scala-dist-pom.xml @@ -39,6 +39,11 @@ scala-compiler @VERSION@ + + org.scala-lang.plugins + scala-continuations-plugin_@VERSION@ + @CONTINUATIONS_PLUGIN_VERSION@ + org.scala-lang.plugins scala-continuations-library_@SCALA_BINARY_VERSION@ From 6ec6990f799f8743c1f6b86f31a0c982888f0358 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Fri, 28 Mar 2014 12:52:24 -0700 Subject: [PATCH 168/826] Skip step bound to fail in Travis PR validation --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 2bad98528e61..eaf3a0b64397 100644 --- a/.travis.yml +++ b/.travis.yml @@ -19,4 +19,4 @@ after_success: - eval "$(ssh-agent)" - ssh-add -D - ssh-add spec/id_dsa_travis - - rsync -e 'ssh -o StrictHostKeyChecking=no' -rzv build/spec/ scalatest@chara.epfl.ch:/home/linuxsoft/archives/scala/spec/2.11/ \ No newline at end of file + - '[ "${TRAVIS_PULL_REQUEST}" = "false" ] && rsync -e "ssh -o StrictHostKeyChecking=no" -rzv build/spec/ scalatest@chara.epfl.ch:/home/linuxsoft/archives/scala/spec/2.11/' \ No newline at end of file From 0f1dcc41cb445eac182c8101a3e0c95594b0f95e Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Fri, 28 Mar 2014 13:44:28 -0700 Subject: [PATCH 169/826] Minor cleanup in aisle README --- spec/README.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/spec/README.md b/spec/README.md index 16752c70defb..4bba86febab4 100644 --- a/spec/README.md +++ b/spec/README.md @@ -12,7 +12,11 @@ We use redcarpet 3.1 and jekyll 2 (currently in alpha) to generate the html. Ess ## Building -Travis CI builds the spec automatically on every commit and . To preview locally, run `bundle exec jekyll serve -d build/spec/ -s spec/ -w --baseurl=""` and surf to http://0.0.0.0:4000/. Jekyll will rebuild as you edit the markdown, but make sure to restart it when you change `_config.yml`. +Travis CI builds the spec automatically on every commit to master and publishes to http://www.scala-lang.org/files/archive/spec/2.11/. + +To preview locally, run `bundle exec jekyll serve -d build/spec/ -s spec/ -w --baseurl=""` (in the root of your checkout of scala/scala), +and open http://0.0.0.0:4000/. Jekyll will rebuild as you edit the markdown, but make sure to restart it when you change `_config.yml`. + ## General Advice for editors From 0b48dc203e0e789646841880f49cd8ae08f6412d Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Fri, 28 Mar 2014 16:45:45 -0700 Subject: [PATCH 170/826] Number files like chapters. Consolidate toc & preface. Aside from the consolidation of title & preface in index.md, this commit was produced as follows: ``` cd spec/ g mv 03-lexical-syntax.md 01-lexical-syntax.md g mv 04-identifiers-names-and-scopes.md 02-identifiers-names-and-scopes.md g mv 05-types.md 03-types.md g mv 06-basic-declarations-and-definitions.md 04-basic-declarations-and-definitions.md g mv 07-classes-and-objects.md 05-classes-and-objects.md g mv 08-expressions.md 06-expressions.md g mv 09-implicit-parameters-and-views.md 07-implicit-parameters-and-views.md g mv 10-pattern-matching.md 08-pattern-matching.md g mv 11-top-level-definitions.md 09-top-level-definitions.md g mv 12-xml-expressions-and-patterns.md 10-xml-expressions-and-patterns.md g mv 13-user-defined-annotations.md 11-user-defined-annotations.md g mv 14-the-scala-standard-library.md 12-the-scala-standard-library.md g mv 15-syntax-summary.md 13-syntax-summary.md g mv 16-references.md 14-references.md perl -pi -e 's/03-lexical-syntax/01-lexical-syntax/g' *.md perl -pi -e 's/04-identifiers-names-and-scopes/02-identifiers-names-and-scopes/g' *.md perl -pi -e 's/05-types/03-types/g' *.md perl -pi -e 's/06-basic-declarations-and-definitions/04-basic-declarations-and-definitions/g' *.md perl -pi -e 's/07-classes-and-objects/05-classes-and-objects/g' *.md perl -pi -e 's/08-expressions/06-expressions/g' *.md perl -pi -e 's/09-implicit-parameters-and-views/07-implicit-parameters-and-views/g' *.md perl -pi -e 's/10-pattern-matching/08-pattern-matching/g' *.md perl -pi -e 's/11-top-level-definitions/09-top-level-definitions/g' *.md perl -pi -e 's/12-xml-expressions-and-patterns/10-xml-expressions-and-patterns/g' *.md perl -pi -e 's/13-user-defined-annotations/11-user-defined-annotations/g' *.md perl -pi -e 's/14-the-scala-standard-library/12-the-scala-standard-library/g' *.md perl -pi -e 's/15-syntax-summary/13-syntax-summary/g' *.md perl -pi -e 's/16-references/14-references/g' *.md ``` --- ...lexical-syntax.md => 01-lexical-syntax.md} | 20 +++--- spec/01-title.md | 12 ---- ....md => 02-identifiers-names-and-scopes.md} | 14 ++-- spec/02-preface.md | 54 --------------- spec/{05-types.md => 03-types.md} | 30 ++++---- ... 04-basic-declarations-and-definitions.md} | 30 ++++---- ...d-objects.md => 05-classes-and-objects.md} | 38 +++++----- spec/{08-expressions.md => 06-expressions.md} | 68 +++++++++--------- ...md => 07-implicit-parameters-and-views.md} | 20 +++--- ...ern-matching.md => 08-pattern-matching.md} | 26 +++---- ...nitions.md => 09-top-level-definitions.md} | 2 +- ....md => 10-xml-expressions-and-patterns.md} | 6 +- ...ions.md => 11-user-defined-annotations.md} | 2 +- ...ry.md => 12-the-scala-standard-library.md} | 12 ++-- ...syntax-summary.md => 13-syntax-summary.md} | 0 spec/{16-references.md => 14-references.md} | 0 spec/_layouts/toc.yml | 15 ++++ spec/index.md | 69 +++++++++++++++++-- 18 files changed, 212 insertions(+), 206 deletions(-) rename spec/{03-lexical-syntax.md => 01-lexical-syntax.md} (96%) delete mode 100644 spec/01-title.md rename spec/{04-identifiers-names-and-scopes.md => 02-identifiers-names-and-scopes.md} (90%) delete mode 100644 spec/02-preface.md rename spec/{05-types.md => 03-types.md} (97%) rename spec/{06-basic-declarations-and-definitions.md => 04-basic-declarations-and-definitions.md} (97%) rename spec/{07-classes-and-objects.md => 05-classes-and-objects.md} (97%) rename spec/{08-expressions.md => 06-expressions.md} (96%) rename spec/{09-implicit-parameters-and-views.md => 07-implicit-parameters-and-views.md} (96%) rename spec/{10-pattern-matching.md => 08-pattern-matching.md} (97%) rename spec/{11-top-level-definitions.md => 09-top-level-definitions.md} (98%) rename spec/{12-xml-expressions-and-patterns.md => 10-xml-expressions-and-patterns.md} (96%) rename spec/{13-user-defined-annotations.md => 11-user-defined-annotations.md} (99%) rename spec/{14-the-scala-standard-library.md => 12-the-scala-standard-library.md} (98%) rename spec/{15-syntax-summary.md => 13-syntax-summary.md} (100%) rename spec/{16-references.md => 14-references.md} (100%) create mode 100644 spec/_layouts/toc.yml diff --git a/spec/03-lexical-syntax.md b/spec/01-lexical-syntax.md similarity index 96% rename from spec/03-lexical-syntax.md rename to spec/01-lexical-syntax.md index c1b4d7f4ba80..64afd9e457b3 100644 --- a/spec/03-lexical-syntax.md +++ b/spec/01-lexical-syntax.md @@ -189,23 +189,23 @@ that a semicolon in place of the newline would be illegal in every one of these cases): - between the condition of a - [conditional expression](08-expressions.html#conditional-expressions) - or [while loop](08-expressions.html#while-loop-expressions) and the next + [conditional expression](06-expressions.html#conditional-expressions) + or [while loop](06-expressions.html#while-loop-expressions) and the next following expression, - between the enumerators of a - [for-comprehension](08-expressions.html#for-comprehensions-and-for-loops) + [for-comprehension](06-expressions.html#for-comprehensions-and-for-loops) and the next following expression, and - after the initial `type` keyword in a - [type definition or declaration](06-basic-declarations-and-definitions.html#type-declarations-and-type-aliases). + [type definition or declaration](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases). A single new line token is accepted - in front of an opening brace ‘{’, if that brace is a legal continuation of the current statement or expression, -- after an [infix operator](08-expressions.html#prefix-infix-and-postfix-operations), +- after an [infix operator](06-expressions.html#prefix-infix-and-postfix-operations), if the first token on the next line can start an expression, -- in front of a [parameter clause](06-basic-declarations-and-definitions.html#function-declarations-and-definitions), and -- after an [annotation](13-user-defined-annotations.html#user-defined-annotations). +- in front of a [parameter clause](04-basic-declarations-and-definitions.html#function-declarations-and-definitions), and +- after an [annotation](11-user-defined-annotations.html#user-defined-annotations). ### Example @@ -343,7 +343,7 @@ type `Long` are all integer numbers between $-2^{63}$ and $2^{63}-1$, inclusive. A compile-time error occurs if an integer literal denotes a number outside these ranges. -However, if the expected type [_pt_](08-expressions.html#expression-typing) of a literal +However, if the expected type [_pt_](06-expressions.html#expression-typing) of a literal in an expression is either `Byte`, `Short`, or `Char` and the integer number fits in the numeric range defined by the type, then the number is converted to type _pt_ and the literal's type @@ -506,7 +506,7 @@ lines. Method `stripMargin` is defined in class [scala.collection.immutable.StringLike](http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.StringLike). Because there is a predefined -[implicit conversion](08-expressions.html#implicit-conversions) from `String` to +[implicit conversion](06-expressions.html#implicit-conversions) from `String` to `StringLike`, the method is applicable to all strings. @@ -541,7 +541,7 @@ symbolLiteral ::= ‘'’ plainid ``` A symbol literal `'x` is a shorthand for the expression -`scala.Symbol("x")`. `Symbol` is a [case class](07-classes-and-objects.html#case-classes), +`scala.Symbol("x")`. `Symbol` is a [case class](05-classes-and-objects.html#case-classes), which is defined as follows. ```scala diff --git a/spec/01-title.md b/spec/01-title.md deleted file mode 100644 index c43908e61c9d..000000000000 --- a/spec/01-title.md +++ /dev/null @@ -1,12 +0,0 @@ ---- -title: The Scala Language Specification -layout: default ---- - -# The Scala Language Specification, Version 2.11 - -## Martin Odersky, Philippe Altherr, Vincent Cremet, Gilles Dubochet, Burak Emir, Philipp Haller, Stéphane Micheloud, Adriaan Moors, Nikolay Mihaylov, Lukas Rytz, Michel Schinz, Erik Stenman, Matthias Zenger - - -## Markdown conversion by Iain McGinniss. - diff --git a/spec/04-identifiers-names-and-scopes.md b/spec/02-identifiers-names-and-scopes.md similarity index 90% rename from spec/04-identifiers-names-and-scopes.md rename to spec/02-identifiers-names-and-scopes.md index 0a3f9ca3cf84..bfb743dbe4a1 100644 --- a/spec/04-identifiers-names-and-scopes.md +++ b/spec/02-identifiers-names-and-scopes.md @@ -8,10 +8,10 @@ chapter: 2 Names in Scala identify types, values, methods, and classes which are collectively called _entities_. Names are introduced by local -[definitions and declarations](06-basic-declarations-and-definitions.html#basic-declarations-and-definitions), -[inheritance](07-classes-and-objects.html#class-members), -[import clauses](06-basic-declarations-and-definitions.html#import-clauses), or -[package clauses](11-top-level-definitions.html#packagings) +[definitions and declarations](04-basic-declarations-and-definitions.html#basic-declarations-and-definitions), +[inheritance](05-classes-and-objects.html#class-members), +[import clauses](04-basic-declarations-and-definitions.html#import-clauses), or +[package clauses](09-top-level-definitions.html#packagings) which are collectively called _bindings_. Bindings of different kinds have a precedence defined on them: @@ -25,8 +25,8 @@ Bindings of different kinds have a precedence defined on them: compilation unit where the definition occurs have lowest precedence. -There are two different name spaces, one for [types](05-types.html#types) -and one for [terms](08-expressions.html#expressions). The same name may designate a +There are two different name spaces, one for [types](03-types.html#types) +and one for [terms](06-expressions.html#expressions). The same name may designate a type and a term, depending on the context where the name is used. A binding has a _scope_ in which the entity defined by a single @@ -67,7 +67,7 @@ of the referenced entity. A reference to a qualified (type- or term-) identifier $e.x$ refers to the member of the type $T$ of $e$ which has the name $x$ in the same -namespace as the identifier. It is an error if $T$ is not a [value type](05-types.html#value-types). +namespace as the identifier. It is an error if $T$ is not a [value type](03-types.html#value-types). The type of $e.x$ is the member type of the referenced entity in $T$. diff --git a/spec/02-preface.md b/spec/02-preface.md deleted file mode 100644 index 50e25d6c00d3..000000000000 --- a/spec/02-preface.md +++ /dev/null @@ -1,54 +0,0 @@ ---- -title: Preface -layout: default ---- - -## Preface - -Scala is a Java-like programming language which unifies -object-oriented and functional programming. It is a pure -object-oriented language in the sense that every value is an -object. Types and behavior of objects are described by -classes. Classes can be composed using mixin composition. Scala is -designed to work seamlessly with two less pure but mainstream -object-oriented languages -- Java and C#. - -Scala is a functional language in the sense that every function is a -value. Nesting of function definitions and higher-order functions are -naturally supported. Scala also supports a general notion of pattern -matching which can model the algebraic types used in many functional -languages. - -Scala has been designed to interoperate seamlessly with Java (an -alternative implementation of Scala also works for .NET). Scala -classes can call Java methods, create Java objects, inherit from Java -classes and implement Java interfaces. None of this requires interface -definitions or glue code. - -Scala has been developed from 2001 in the programming methods -laboratory at EPFL. Version 1.0 was released in November 2003. This -document describes the second version of the language, which was -released in March 2006. It acts a reference for the language -definition and some core library modules. It is not intended to teach -Scala or its concepts; for this there are other documents -[@scala-overview-tech-report; -@odersky:scala-experiment; -@odersky:sca; -@odersky-et-al:ecoop03; -@odersky-zenger:fool12] - -Scala has been a collective effort of many people. The design and the -implementation of version 1.0 was completed by Philippe Altherr, -Vincent Cremet, Gilles Dubochet, Burak Emir, Stéphane Micheloud, -Nikolay Mihaylov, Michel Schinz, Erik Stenman, Matthias Zenger, and -the author. Iulian Dragos, Gilles Dubochet, Philipp Haller, Sean -McDirmid, Lex Spoon, and Geoffrey Washburn joined in the effort to -develop the second version of the language and tools. Gilad Bracha, -Craig Chambers, Erik Ernst, Matthias Felleisen, Shriram Krishnamurti, -Gary Leavens, Sebastian Maneth, Erik Meijer, Klaus Ostermann, Didier -Rémy, Mads Torgersen, and Philip Wadler have shaped the design of -the language through lively and inspiring discussions and comments on -previous versions of this document. The contributors to the Scala -mailing list have also given very useful feedback that helped us -improve the language and its tools. - diff --git a/spec/05-types.md b/spec/03-types.md similarity index 97% rename from spec/05-types.md rename to spec/03-types.md index f614d15f8f03..c765a7681222 100644 --- a/spec/05-types.md +++ b/spec/03-types.md @@ -35,15 +35,15 @@ Value types are either _concrete_ or _abstract_. Every concrete value type can be represented as a _class type_, i.e. a [type designator](#type-designators) that refers to a -[class or a trait](07-classes-and-objects.html#class-definitions) [^1], or as a +[class or a trait](05-classes-and-objects.html#class-definitions) [^1], or as a [compound type](#compound-types) representing an intersection of types, possibly with a [refinement](#compound-types) that further constrains the types of its members. -Abstract value types are introduced by [type parameters](06-basic-declarations-and-definitions.html#type-parameters) -and [abstract type bindings](06-basic-declarations-and-definitions.html#type-declarations-and-type-aliases). +Abstract value types are introduced by [type parameters](04-basic-declarations-and-definitions.html#type-parameters) +and [abstract type bindings](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases). Parentheses in types can be used for grouping. [^1]: We assume that objects and packages also implicitly @@ -108,7 +108,7 @@ SimpleType ::= Path ‘.’ type ``` A singleton type is of the form `$p$.type`, where $p$ is a -path pointing to a value expected to [conform](08-expressions.html#expression-typing) +path pointing to a value expected to [conform](06-expressions.html#expression-typing) to `scala.AnyRef`. The type denotes the set of values consisting of `null` and the value denoted by $p$. @@ -259,7 +259,7 @@ AnnotType ::= SimpleType {Annotation} ``` An annotated type $T$ `$a_1 , \ldots , a_n$` -attaches [annotations](13-user-defined-annotations.html#user-defined-annotations) +attaches [annotations](11-user-defined-annotations.html#user-defined-annotations) $a_1 , \ldots , a_n$ to the type $T$. ### Example @@ -288,7 +288,7 @@ $T_1 , \ldots , T_n$ and the refinement `{ $R$ }`. A refinement `{ $R$ }` contains declarations and type definitions. If a declaration or definition overrides a declaration or definition in one of the component types $T_1 , \ldots , T_n$, the usual rules for -[overriding](07-classes-and-objects.html#overriding) apply; otherwise the declaration +[overriding](05-classes-and-objects.html#overriding) apply; otherwise the declaration or definition is said to be “structural” [^2]. [^2]: A reference to a structurally defined member (method call or access @@ -355,10 +355,10 @@ $T_2$. The type is equivalent to the type application `$\mathit{op}$[$T_1$, $T_2$]`. The infix operator $\mathit{op}$ may be an arbitrary identifier, except for `*`, which is reserved as a postfix modifier -denoting a [repeated parameter type](06-basic-declarations-and-definitions.html#repeated-parameters). +denoting a [repeated parameter type](04-basic-declarations-and-definitions.html#repeated-parameters). All type infix operators have the same precedence; parentheses have to -be used for grouping. The [associativity](08-expressions.html#prefix-infix-and-postfix-operations) +be used for grouping. The [associativity](06-expressions.html#prefix-infix-and-postfix-operations) of a type operator is determined as for term operators: type operators ending in a colon ‘:’ are right-associative; all other operators are left-associative. @@ -385,7 +385,7 @@ values that take arguments of types $T1 , \ldots , Tn$ and yield results of type $U$. In the case of exactly one argument type $T \Rightarrow U$ is a shorthand for $(T) \Rightarrow U$. An argument type of the form $\Rightarrow T$ -represents a [call-by-name parameter](06-basic-declarations-and-definitions.html#by-name-parameters) of type $T$. +represents a [call-by-name parameter](04-basic-declarations-and-definitions.html#by-name-parameters) of type $T$. Function types associate to the right, e.g. $S \Rightarrow T \Rightarrow U$ is the same as @@ -405,7 +405,7 @@ trait Function_n[-T1 , … , -T$_n$, +R] { } ``` -Hence, function types are [covariant](06-basic-declarations-and-definitions.html#variance-annotations) in their +Hence, function types are [covariant](04-basic-declarations-and-definitions.html#variance-annotations) in their result type and contravariant in their argument types. ### Existential Types @@ -420,7 +420,7 @@ ExistentialDcl ::= ‘type’ TypeDcl An existential type has the form `$T$ forSome { $Q$ }` where $Q$ is a sequence of -[type declarations](06-basic-declarations-and-definitions.html#type-declarations-and-type-aliases). +[type declarations](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases). Let $t_1[\mathit{tps}_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}_n] >: L_n <: U_n$ @@ -462,7 +462,7 @@ is equivalent to 1. An existential type `$T$ forSome { $Q$ }` where $Q$ contains a clause `type $t[\mathit{tps}] >: L <: U$` is equivalent to the type `$T'$ forSome { $Q$ }` where $T'$ results from $T$ by replacing -every [covariant occurrence](06-basic-declarations-and-definitions.html#variance-annotations) of $t$ in $T$ by $U$ and by +every [covariant occurrence](04-basic-declarations-and-definitions.html#variance-annotations) of $t$ in $T$ by $U$ and by replacing every contravariant occurrence of $t$ in $T$ by $L$. @@ -591,7 +591,7 @@ that are re-evaluated each time the parameterless method name is referenced. Method types do not exist as types of values. If a method name is used -as a value, its type is [implicitly converted](08-expressions.html#implicit-conversions) to a +as a value, its type is [implicitly converted](06-expressions.html#implicit-conversions) to a corresponding function type. ###### Example @@ -645,8 +645,8 @@ union : [A >: Nothing <: Comparable[A]] (x: Set[A], xs: Set[A]) Set[A] . A type constructor is represented internally much like a polymorphic method type. `[$\pm$ $a_1$ >: $L_1$ <: $U_1 , \ldots , \pm a_n$ >: $L_n$ <: $U_n$] $T$` represents a type that is expected by a -[type constructor parameter](06-basic-declarations-and-definitions.html#type-parameters) or an -[abstract type constructor binding](06-basic-declarations-and-definitions.html#type-declarations-and-type-aliases) with +[type constructor parameter](04-basic-declarations-and-definitions.html#type-parameters) or an +[abstract type constructor binding](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases) with the corresponding type parameter clause. ###### Example diff --git a/spec/06-basic-declarations-and-definitions.md b/spec/04-basic-declarations-and-definitions.md similarity index 97% rename from spec/06-basic-declarations-and-definitions.md rename to spec/04-basic-declarations-and-definitions.md index e0fdf051c24e..ab1f98ea0793 100644 --- a/spec/06-basic-declarations-and-definitions.md +++ b/spec/04-basic-declarations-and-definitions.md @@ -21,8 +21,8 @@ Def ::= PatVarDef ``` A _declaration_ introduces names and assigns them types. It can -form part of a [class definition](07-classes-and-objects.html#templates) or of a -refinement in a [compound type](05-types.html#compound-types). +form part of a [class definition](05-classes-and-objects.html#templates) or of a +refinement in a [compound type](03-types.html#compound-types). A _definition_ introduces names that denote terms or types. It can form part of an object or class definition or it can be local to a @@ -116,7 +116,7 @@ type $T$. A value definition `val $x$: $T$ = $e$` defines $x$ as a name of the value that results from the evaluation of $e$. If the value definition is not recursive, the type -$T$ may be omitted, in which case the [packed type](08-expressions.html#expression-typing) of +$T$ may be omitted, in which case the [packed type](06-expressions.html#expression-typing) of expression $e$ is assumed. If a type $T$ is given, then $e$ is expected to conform to it. @@ -132,13 +132,13 @@ A _constant value definition_ is of the form final val x = e ``` -where `e` is a [constant expression](08-expressions.html#constant-expressions). +where `e` is a [constant expression](06-expressions.html#constant-expressions). The `final` modifier must be present and no type annotation may be given. References to the constant value `x` are themselves treated as constant expressions; in the generated code they are replaced by the definition's right-hand side `e`. -Value definitions can alternatively have a [pattern](10-pattern-matching.html#patterns) +Value definitions can alternatively have a [pattern](08-pattern-matching.html#patterns) as left-hand side. If $p$ is some pattern other than a simple name or a name followed by a colon and a type, then the value definition `val $p$ = $e$` is expanded as follows: @@ -223,9 +223,9 @@ A variable definition `var $x$: $T$ = $e$` introduces a mutable variable with type $T$ and initial value as given by the expression $e$. The type $T$ can be omitted, in which case the type of $e$ is assumed. If $T$ is given, then $e$ is expected to -[conform to it](08-expressions.html#expression-typing). +[conform to it](06-expressions.html#expression-typing). -Variable definitions can alternatively have a [pattern](10-pattern-matching.html#patterns) +Variable definitions can alternatively have a [pattern](08-pattern-matching.html#patterns) as left-hand side. A variable definition `var $p$ = $e$` where $p$ is a pattern other than a simple name or a name followed by a colon and a type is expanded in the same way @@ -326,7 +326,7 @@ the top type `scala.Any` is assumed. A type constructor declaration imposes additional restrictions on the concrete types for which $t$ may stand. Besides the bounds $L$ and $U$, the type parameter clause may impose higher-order bounds and -variances, as governed by the [conformance of type constructors](05-types.html#conformance). +variances, as governed by the [conformance of type constructors](03-types.html#conformance). The scope of a type parameter extends over the bounds `>: $L$ <: $U$` and the type parameter clause $\mathit{tps}$ itself. A higher-order type parameter clause (of an abstract type constructor @@ -414,7 +414,7 @@ function definitions. In this section we consider only type parameter definitions with lower bounds `>: $L$` and upper bounds `<: $U$` whereas a discussion of context bounds `: $U$` and view bounds `<% $U$` -is deferred to [here](09-implicit-parameters-and-views.html#context-bounds-and-view-bounds). +is deferred to [here](07-implicit-parameters-and-views.html#context-bounds-and-view-bounds). The most general form of a first-order type parameter is `$@a_1 \ldots @a_n$ $\pm$ $t$ >: $L$ <: $U$`. @@ -468,7 +468,7 @@ The following type parameter clauses are illegal: ## Variance Annotations Variance annotations indicate how instances of parameterized types -vary with respect to [subtyping](05-types.html#conformance). A +vary with respect to [subtyping](03-types.html#conformance). A ‘+’ variance indicates a covariant dependency, a ‘-’ variance indicates a contravariant dependency, and a missing variance indication indicates an invariant dependency. @@ -511,7 +511,7 @@ changes at the following constructs. References to the type parameters in -[object-private or object-protected values, types, variables, or methods](07-classes-and-objects.html#modifiers) of the class are not +[object-private or object-protected values, types, variables, or methods](05-classes-and-objects.html#modifiers) of the class are not checked for their variance position. In these members the type parameter may appear anywhere without restricting its legal variance annotations. @@ -618,7 +618,7 @@ followed by zero or more value parameter clauses introduces a value with a (possibly polymorphic) method type whose parameter types and result type are as given. -The type of the function body is expected to [conform](08-expressions.html#expression-typing) +The type of the function body is expected to [conform](06-expressions.html#expression-typing) to the function's declared result type, if one is given. If the function definition is not recursive, the result type may be omitted, in which case it is @@ -688,7 +688,7 @@ The by-name modifier is disallowed for parameters of classes that carry a `val` or `var` prefix, including parameters of case classes for which a `val` prefix is implicitly generated. The by-name modifier is also disallowed for -[implicit parameters](09-implicit-parameters-and-views.html#implicit-parameters). +[implicit parameters](07-implicit-parameters-and-views.html#implicit-parameters). ###### Example The declaration @@ -868,10 +868,10 @@ ImportSelector ::= id [‘=>’ id | ‘=>’ ‘_’] ``` An import clause has the form `import $p$.$I$` where $p$ is a -[stable identifier](05-types.html#paths) and $I$ is an import expression. +[stable identifier](03-types.html#paths) and $I$ is an import expression. The import expression determines a set of names of importable members of $p$ which are made available without qualification. A member $m$ of $p$ is -_importable_ if it is not [object-private](07-classes-and-objects.html#modifiers). +_importable_ if it is not [object-private](05-classes-and-objects.html#modifiers). The most general form of an import expression is a list of _import selectors_ ```scala diff --git a/spec/07-classes-and-objects.md b/spec/05-classes-and-objects.md similarity index 97% rename from spec/07-classes-and-objects.md rename to spec/05-classes-and-objects.md index 08528037672e..70fa3e0272f6 100644 --- a/spec/07-classes-and-objects.md +++ b/spec/05-classes-and-objects.md @@ -60,7 +60,7 @@ chain in the inheritance hierarchy which starts with the template's superclass. The _least proper supertype_ of a template is the class type or -[compound type](05-types.html#compound-types) consisting of all its parent +[compound type](03-types.html#compound-types) consisting of all its parent class types. The statement sequence $\mathit{stats}$ contains member definitions that @@ -157,10 +157,10 @@ objects created by an instance creation expression, or of parts of an object's definition which are inherited by a class or object definition. A constructor invocation is a function application `$x$.$c$[$\mathit{targs}$]($\mathit{args}_1$)$\ldots$($\mathit{args}_n$)`, where $x$ is a -[stable identifier](05-types.html#paths), $c$ is a type name which either designates a +[stable identifier](03-types.html#paths), $c$ is a type name which either designates a class or defines an alias type for one, $\mathit{targs}$ is a type argument list, $\mathit{args}_1 , \ldots , \mathit{args}_n$ are argument lists, and there is a -constructor of that class which is [applicable](08-expressions.html#function-applications) +constructor of that class which is [applicable](06-expressions.html#function-applications) to the given arguments. If the constructor invocation uses named or default arguments, it is transformed into a block expression using the same transformation as described [here](sec:named-default). @@ -168,7 +168,7 @@ same transformation as described [here](sec:named-default). The prefix `$x$.` can be omitted. A type argument list can be given only if the class $c$ takes type parameters. Even then it can be omitted, in which case a type argument list is synthesized -using [local type inference](08-expressions.html#local-type-inference). If no explicit +using [local type inference](06-expressions.html#local-type-inference). If no explicit arguments are given, an empty list `()` is implicitly supplied. An evaluation of a constructor invocation @@ -302,7 +302,7 @@ linearization of $C$) the class in which $M'$ is defined. It is an error if a template directly defines two matching members. It is also an error if a template contains two members (directly defined -or inherited) with the same name and the same [erased type](05-types.html#type-erasure). +or inherited) with the same name and the same [erased type](03-types.html#type-erasure). Finally, a template is not allowed to contain two methods (directly defined or inherited) with the same name which both define default arguments. @@ -329,7 +329,7 @@ trait `B`. A member $M$ of class $C$ that [matches](#class-members) a non-private member $M'$ of a base class of $C$ is said to _override_ that member. In this case -the binding of the overriding member $M$ must [subsume](05-types.html#conformance) +the binding of the overriding member $M$ must [subsume](03-types.html#conformance) the binding of the overridden member $M'$. Furthermore, the following restrictions on modifiers apply to $M$ and $M'$: @@ -361,7 +361,7 @@ class Y extends X { override var stable = 1 } // error ``` Another restriction applies to abstract type members: An abstract type -member with a [volatile type](05-types.html#volatile-types) as its upper +member with a [volatile type](03-types.html#volatile-types) as its upper bound may not override an abstract type member which does not have a volatile upper bound. @@ -594,7 +594,7 @@ it is _concrete_ if a full definition is given. The `abstract` modifier is used in class definitions. It is redundant for traits, and mandatory for all other classes which have incomplete members. Abstract classes cannot be -[instantiated](08-expressions.html#instance-creation-expressions) with a constructor invocation +[instantiated](06-expressions.html#instance-creation-expressions) with a constructor invocation unless followed by mixins and/or a refinement which override all incomplete members of the class. Only abstract classes and traits can have abstract term members. @@ -610,7 +610,7 @@ overridden in subclasses. A `final` class may not be inherited by a template. `final` is redundant for object definitions. Members of final classes or objects are implicitly also final, so the `final` modifier is generally redundant for them, too. Note, however, that -[constant value definitions](06-basic-declarations-and-definitions.html#value-declarations-and-definitions) do require +[constant value definitions](04-basic-declarations-and-definitions.html#value-declarations-and-definitions) do require an explicit `final` modifier, even if they are defined in a final class or object. `final` may not be applied to incomplete members, and it may not be combined in one modifier list with `sealed`. @@ -713,7 +713,7 @@ Here, parameter section is called _polymorphic_, otherwise it is called _monomorphic_. - $as$ is a possibly empty sequence of - [annotations](13-user-defined-annotations.html#user-defined-annotations). + [annotations](11-user-defined-annotations.html#user-defined-annotations). If any annotations are given, they apply to the primary constructor of the class. - $m$ is an [access modifier](#modifiers) such as @@ -728,16 +728,16 @@ Here, If no formal parameter sections are given, an empty parameter section `()` is assumed. If a formal parameter declaration $x: T$ is preceded by a `val` - or `var` keyword, an accessor (getter) [definition](06-basic-declarations-and-definitions.html#variable-declarations-and-definitions) + or `var` keyword, an accessor (getter) [definition](04-basic-declarations-and-definitions.html#variable-declarations-and-definitions) for this parameter is implicitly added to the class. The getter introduces a value member $x$ of class $c$ that is defined as an alias of the parameter. - If the introducing keyword is `var`, a setter accessor [`$x$_=`](06-basic-declarations-and-definitions.html#variable-declarations-and-definitions) is also implicitly added to the class. + If the introducing keyword is `var`, a setter accessor [`$x$_=`](04-basic-declarations-and-definitions.html#variable-declarations-and-definitions) is also implicitly added to the class. In invocation of that setter `$x$_=($e$)` changes the value of the parameter to the result of evaluating $e$. The formal parameter declaration may contain modifiers, which then carry over to the accessor definition(s). When access modifiers are given for a parameter, but no `val` or `var` keyword, `val` is assumed. - A formal parameter prefixed by `val` or `var` may not at the same time be a [call-by-name parameter](06-basic-declarations-and-definitions.html#by-name-parameters). + A formal parameter prefixed by `val` or `var` may not at the same time be a [call-by-name parameter](04-basic-declarations-and-definitions.html#by-name-parameters). - $t$ is a [template](#templates) of the form @@ -823,7 +823,7 @@ If there are auxiliary constructors of a class $C$, they form together with $C$'s primary [constructor](#class-definitions) an overloaded constructor definition. The usual rules for -[overloading resolution](08-expressions.html#overloading-resolution) +[overloading resolution](06-expressions.html#overloading-resolution) apply for constructor invocations of $C$, including for the self constructor invocations in the constructor expressions themselves. However, unlike other methods, constructors @@ -871,7 +871,7 @@ definition for the parameter is [generated](#class-definitions). A case class definition of `$c$[$\mathit{tps}\,$]($\mathit{ps}_1\,$)$\ldots$($\mathit{ps}_n$)` with type parameters $\mathit{tps}$ and value parameters $\mathit{ps}$ implicitly -generates an [extractor object](10-pattern-matching.html#extractor-patterns) which is +generates an [extractor object](08-pattern-matching.html#extractor-patterns) which is defined as follows: ```scala @@ -905,7 +905,7 @@ def unapply[$\mathit{tps}\,$]($x$: $c$[$\mathit{tps}\,$]) = x ne null The name of the `unapply` method is changed to `unapplySeq` if the first parameter section $\mathit{ps}_1$ of $c$ ends in a -[repeated parameter](06-basic-declarations-and-definitions.html#repeated-parameters). +[repeated parameter](04-basic-declarations-and-definitions.html#repeated-parameters). If a companion object $c$ exists already, no new object is created, but the `apply` and `unapply` methods are added to the existing object instead. @@ -926,7 +926,7 @@ In all cases `$x_{i,j}$` and `$T_{i,j}$` refer to the name and type of the corre `$\mathit{ps}_{i,j}$`. Every case class implicitly overrides some method definitions of class -[`scala.AnyRef`](14-the-scala-standard-library.html#root-classes) unless a definition of the same +[`scala.AnyRef`](12-the-scala-standard-library.html#root-classes) unless a definition of the same method is already given in the case class itself or a concrete definition of the same method is given in some base class of the case class different from `AnyRef`. In particular: @@ -1002,7 +1002,7 @@ initialized after the superclass is initialized. Assume a trait $D$ defines some aspect of an instance $x$ of type $C$ (i.e. $D$ is a base class of $C$). Then the _actual supertype_ of $D$ in $x$ is the compound type consisting of all the base classes in $\mathcal{L}(C)$ that succeed $D$. The actual supertype gives -the context for resolving a [`super` reference](08-expressions.html#this-and-super) in a trait. +the context for resolving a [`super` reference](06-expressions.html#this-and-super) in a trait. Note that the actual supertype depends on the type to which the trait is added in a mixin composition; it is not statically known at the time the trait is defined. @@ -1133,7 +1133,7 @@ constructor is being evaluated block until evaluation is complete. The expansion given above is not accurate for top-level objects. It cannot be because variable and method definition cannot appear on the -top-level outside of a [package object](11-top-level-definitions.html#package-objects). Instead, +top-level outside of a [package object](09-top-level-definitions.html#package-objects). Instead, top-level objects are translated to static fields. ###### Example diff --git a/spec/08-expressions.md b/spec/06-expressions.md similarity index 96% rename from spec/08-expressions.md rename to spec/06-expressions.md index db1bd182cd5a..9a558420dd24 100644 --- a/spec/08-expressions.md +++ b/spec/06-expressions.md @@ -59,7 +59,7 @@ The typing of expressions is often relative to some _expected type_ (which migh The following skolemization rule is applied universally for every expression: If the type of an expression would be an existential type $T$, then the type of the expression is assumed instead to be a -[skolemization](05-types.html#existential-types) of $T$. +[skolemization](03-types.html#existential-types) of $T$. Skolemization is reversed by type packing. Assume an expression $e$ of type $T$ and let $t_1[\mathit{tps}_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}_n] >: L_n <: U_n$ be @@ -77,7 +77,7 @@ $T$ forSome { type $t_1[\mathit{tps}_1] >: L_1 <: U_1$; $\ldots$; type $t_n[\mat SimpleExpr ::= Literal ``` -Typing of literals is as described [here](03-lexical-syntax.html#literals); their +Typing of literals is as described [here](01-lexical-syntax.html#literals); their evaluation is immediate. @@ -93,7 +93,7 @@ implements methods in class `scala.AnyRef` as follows: - `ne($x\,$)` and `!=($x\,$)` return true iff the argument x is not also the "null" object. - `isInstanceOf[$T\,$]` always returns `false`. -- `asInstanceOf[$T\,$]` returns the [default value](06-basic-declarations-and-definitions.html#value-declarations-and-definitions) of type $T$. +- `asInstanceOf[$T\,$]` returns the [default value](04-basic-declarations-and-definitions.html#value-declarations-and-definitions) of type $T$. - `##` returns ``0``. A reference to any other member of the "null" object causes a @@ -111,14 +111,14 @@ A designator refers to a named term. It can be a _simple name_ or a _selection_. A simple name $x$ refers to a value as specified -[here](04-identifiers-names-and-scopes.html#identifiers-names-and-scopes). +[here](02-identifiers-names-and-scopes.html#identifiers-names-and-scopes). If $x$ is bound by a definition or declaration in an enclosing class or object $C$, it is taken to be equivalent to the selection `$C$.this.$x$` where $C$ is taken to refer to the class containing $x$ -even if the type name $C$ is [shadowed](04-identifiers-names-and-scopes.html#identifiers-names-and-scopes) at the +even if the type name $C$ is [shadowed](02-identifiers-names-and-scopes.html#identifiers-names-and-scopes) at the occurrence of $x$. -If $r$ is a [stable identifier](05-types.html#paths) of type $T$, the selection $r.x$ refers +If $r$ is a [stable identifier](03-types.html#paths) of type $T$, the selection $r.x$ refers statically to a term member $m$ of $r$ that is identified in $T$ by the name $x$. @@ -132,8 +132,8 @@ $y$. The expected type of a designator's prefix is always undefined. The type of a designator is the type $T$ of the entity it refers to, with -the following exception: The type of a [path](05-types.html#paths) $p$ -which occurs in a context where a [stable type](05-types.html#singleton-types) +the following exception: The type of a [path](03-types.html#paths) $p$ +which occurs in a context where a [stable type](03-types.html#singleton-types) is required is the singleton type `$p$.type`. The contexts where a stable type is required are those that satisfy @@ -308,7 +308,7 @@ and the argument passed to the function is `$y_i$()`. The last argument in an application may be marked as a sequence argument, e.g. `$e$: _*`. Such an argument must correspond -to a [repeated parameter](06-basic-declarations-and-definitions.html#repeated-parameters) of type +to a [repeated parameter](04-basic-declarations-and-definitions.html#repeated-parameters) of type `$S$*` and it must be the only argument matching this parameter (i.e. the number of formal parameters and actual arguments must be the same). Furthermore, the type of $e$ must conform to @@ -396,7 +396,7 @@ positional arguments and to $e'_i$ for named arguments of the form `$x_i=e'_i$`. Then, for every parameter which is not specified by the argument list, a value definition using a fresh name $z_i$ is created, which is initialized using the method computing the -[default argument](06-basic-declarations-and-definitions.html#function-declarations-and-definitions) of +[default argument](04-basic-declarations-and-definitions.html#function-declarations-and-definitions) of this parameter. Let $\mathit{args}$ be a permutation of the generated names $y_i$ and $z_i$ such such @@ -501,11 +501,11 @@ SimpleExpr ::= `new' (ClassTemplate | TemplateBody) A simple instance creation expression is of the form `new $c$` -where $c$ is a [constructor invocation](07-classes-and-objects.html#constructor-invocations). Let $T$ be +where $c$ is a [constructor invocation](05-classes-and-objects.html#constructor-invocations). Let $T$ be the type of $c$. Then $T$ must denote a (a type instance of) a non-abstract subclass of `scala.AnyRef`. Furthermore, the _concrete self type_ of the -expression must conform to the [self type](07-classes-and-objects.html#templates) of the class denoted by +expression must conform to the [self type](05-classes-and-objects.html#templates) of the class denoted by $T$. The concrete self type is normally $T$, except if the expression `new $c$` appears as the right hand side of a value definition @@ -523,7 +523,7 @@ object of type $T$ which is is initialized by evaluating $c$. The type of the expression is $T$. A general instance creation expression is of the form -`new $t$` for some [class template](07-classes-and-objects.html#templates) $t$. +`new $t$` for some [class template](05-classes-and-objects.html#templates) $t$. Such an expression is equivalent to the block ```scala @@ -582,7 +582,7 @@ undefined. The type of a block `$s_1$; $\ldots$; $s_n$; $e$` is `$T$ forSome {$\,Q\,$}`, where $T$ is the type of $e$ and $Q$ -contains [existential clauses](05-types.html#existential-types) +contains [existential clauses](03-types.html#existential-types) for every value or type name which is free in $T$ and which is defined locally in one of the statements $s_1 , \ldots , s_n$. We say the existential clause _binds_ the occurrence of the value or type name. @@ -620,7 +620,7 @@ The block { class C extends B {$\ldots$} ; new C } ``` -simply has type `B`, because with the rules [here](05-types.html#simplification-rules) +simply has type `B`, because with the rules [here](03-types.html#simplification-rules) the existentially quantified type `_1 forSome { type _1 <: B }` can be simplified to `B`. @@ -727,7 +727,7 @@ name. ### Assignment Operators An assignment operator is an operator symbol (syntax category -`op` in [Identifiers](03-lexical-syntax.html#identifiers)) that ends in an equals character +`op` in [Identifiers](01-lexical-syntax.html#identifiers)) that ends in an equals character “`=`”, with the exception of operators for which one of the following conditions holds: @@ -787,7 +787,7 @@ Expr1 ::= PostfixExpr `:' Annotation {Annotation} ``` An annotated expression `$e$: @$a_1$ $\ldots$ @$a_n$` -attaches [annotations](13-user-defined-annotations.html#user-defined-annotations) $a_1 , \ldots , a_n$ to the +attaches [annotations](11-user-defined-annotations.html#user-defined-annotations) $a_1 , \ldots , a_n$ to the expression $e$. @@ -889,7 +889,7 @@ value of $e_1$. The condition $e_1$ is expected to conform to type `Boolean`. The then-part $e_2$ and the else-part $e_3$ are both expected to conform to the expected type of the conditional expression. The type of the conditional -expression is the [weak least upper bound](05-types.html#weak-conformance) +expression is the [weak least upper bound](03-types.html#weak-conformance) of the types of $e_2$ and $e_3$. A semicolon preceding the `else` symbol of a conditional expression is ignored. @@ -958,7 +958,7 @@ defined by translation to invocations of four methods: `map`, be implemented in different ways for different carrier types. The translation scheme is as follows. In a first step, every -generator `$p$ <- $e$`, where $p$ is not [irrefutable](10-pattern-matching.html#patterns) +generator `$p$ <- $e$`, where $p$ is not [irrefutable](08-pattern-matching.html#patterns) for the type of $e$ is replaced by ```scala @@ -1164,7 +1164,7 @@ Let $\mathit{pt}$ be the expected type of the try expression. The block $b$ is expected to conform to $\mathit{pt}$. The handler $h$ is expected conform to type `scala.PartialFunction[scala.Throwable, $\mathit{pt}\,$]`. The -type of the try expression is the [weak least upper bound](05-types.html#weak-conformance) +type of the try expression is the [weak least upper bound](03-types.html#weak-conformance) of the type of $b$ and the result type of $h$. @@ -1239,9 +1239,9 @@ In that case, a fresh name for the parameter is chosen arbitrarily. A named parameter of an anonymous function may be optionally preceded by an `implicit` modifier. In that case the parameter is -labeled [`implicit`](09-implicit-parameters-and-views.html#implicit-parameters-and-views); however the +labeled [`implicit`](07-implicit-parameters-and-views.html#implicit-parameters-and-views); however the parameter section itself does not count as an implicit parameter -section in the sense defined [here](09-implicit-parameters-and-views.html#implicit-parameters). Hence, arguments to +section in the sense defined [here](07-implicit-parameters-and-views.html#implicit-parameters). Hence, arguments to anonymous functions always have to be given explicitly. ###### Example @@ -1312,13 +1312,13 @@ include at least the expressions of the following forms: - A literal of a value class, such as an integer - A string literal -- A class constructed with [`Predef.classOf`](14-the-scala-standard-library.html#the-predef-object) +- A class constructed with [`Predef.classOf`](12-the-scala-standard-library.html#the-predef-object) - An element of an enumeration from the underlying platform - A literal array, of the form `Array$(c_1 , \ldots , c_n)$`, where all of the $c_i$'s are themselves constant expressions - An identifier defined by a - [constant value definition](06-basic-declarations-and-definitions.html#value-declarations-and-definitions). + [constant value definition](04-basic-declarations-and-definitions.html#value-declarations-and-definitions). ## Statements @@ -1363,7 +1363,7 @@ available implicit conversions are given in the next two sub-sections. We say, a type $T$ is _compatible_ to a type $U$ if $T$ weakly conforms to $U$ after applying [eta-expansion](#eta-expansion) and -[view applications](09-implicit-parameters-and-views.html#views). +[view applications](07-implicit-parameters-and-views.html#views). ### Value Conversions @@ -1393,11 +1393,11 @@ implicitly embedding $e$ in the [type application](#type-applications) `$e$[$T_1 , \ldots , T_n$]`. ###### Numeric Widening -If $e$ has a primitive number type which [weakly conforms](05-types.html#weak-conformance) +If $e$ has a primitive number type which [weakly conforms](03-types.html#weak-conformance) to the expected type, it is widened to the expected type using one of the numeric conversion methods `toShort`, `toChar`, `toInt`, `toLong`, -`toFloat`, `toDouble` defined [here](14-the-scala-standard-library.html#numeric-value-types). +`toFloat`, `toDouble` defined [here](12-the-scala-standard-library.html#numeric-value-types). ###### Numeric Literal Narrowing If the expected type is `Byte`, `Short` or `Char`, and @@ -1412,7 +1412,7 @@ term `{ $e$; () }`. ###### View Application If none of the previous conversions applies, and $e$'s type does not conform to the expected type $\mathit{pt}$, it is attempted to convert -$e$ to the expected type with a [view](09-implicit-parameters-and-views.html#views). +$e$ to the expected type with a [view](07-implicit-parameters-and-views.html#views). ###### Dynamic Member Selection If none of the previous conversions applies, and $e$ is a prefix @@ -1431,7 +1431,7 @@ type $T$ by evaluating the expression to which $m$ is bound. ###### Implicit Application If the method takes only implicit parameters, implicit -arguments are passed following the rules [here](09-implicit-parameters-and-views.html#implicit-parameters). +arguments are passed following the rules [here](07-implicit-parameters-and-views.html#implicit-parameters). ###### Eta Expansion Otherwise, if the method is not a constructor, @@ -1608,7 +1608,7 @@ $T$ is a value type; if it is a method type we apply means finding a substitution $\sigma$ of types $T_i$ for the type parameters $a_i$ such that -- None of inferred types $T_i$ is a [singleton type](05-types.html#singleton-types) +- None of inferred types $T_i$ is a [singleton type](03-types.html#singleton-types) - All type parameter bounds are respected, i.e. $\sigma L_i <: \sigma a_i$ and $\sigma a_i <: \sigma U_i$ for $i = 1 , \ldots , n$. - The expression's type conforms to the expected type, i.e. @@ -1618,7 +1618,7 @@ It is a compile time error if no such substitution exists. If several substitutions exist, local-type inference will choose for each type variable $a_i$ a minimal or maximal type $T_i$ of the solution space. A _maximal_ type $T_i$ will be chosen if the type -parameter $a_i$ appears [contravariantly](06-basic-declarations-and-definitions.html#variance-annotations) in the +parameter $a_i$ appears [contravariantly](04-basic-declarations-and-definitions.html#variance-annotations) in the type $T$ of the expression. A _minimal_ type $T_i$ will be chosen in all other situations, i.e. if the variable appears covariantly, non-variantly or not at all in the type $T$. We call such a substitution @@ -1645,11 +1645,11 @@ constraint system means finding a substitution $\sigma$ of types $T_i$ for the type parameters $a_i$ such that -- None of inferred types $T_i$ is a [singleton type](05-types.html#singleton-types) +- None of inferred types $T_i$ is a [singleton type](03-types.html#singleton-types) - All type parameter bounds are respected, i.e. $\sigma L_i <: \sigma a_i$ and $\sigma a_i <: \sigma U_i$ for $i = 1 , \ldots , n$. - The method's result type $T'$ conforms to the expected type, i.e. $\sigma T' <: \sigma \mathit{pt}$. -- Each argument type [weakly conforms](05-types.html#weak-conformance) +- Each argument type [weakly conforms](03-types.html#weak-conformance) to the corresponding formal parameter type, i.e. $\sigma S_j <:_w \sigma R_j$ for $j = 1 , \ldots , m$. @@ -1657,7 +1657,7 @@ It is a compile time error if no such substitution exists. If several solutions exist, an optimal one for the type $T'$ is chosen. All or parts of an expected type $\mathit{pt}$ may be undefined. The rules for -[conformance](05-types.html#conformance) are extended to this case by adding +[conformance](03-types.html#conformance) are extended to this case by adding the rule that for any type $T$ the following two statements are always true: $\mathit{undefined} <: T$ and $T <: \mathit{undefined}$ diff --git a/spec/09-implicit-parameters-and-views.md b/spec/07-implicit-parameters-and-views.md similarity index 96% rename from spec/09-implicit-parameters-and-views.md rename to spec/07-implicit-parameters-and-views.md index 3e821ec9fa48..1a4d70409c0c 100644 --- a/spec/09-implicit-parameters-and-views.md +++ b/spec/07-implicit-parameters-and-views.md @@ -17,7 +17,7 @@ Template members and parameters labeled with an `implicit` modifier can be passed to [implicit parameters](#implicit-parameters) and can be used as implicit conversions called [views](#views). The `implicit` modifier is illegal for all -type members, as well as for [top-level objects](11-top-level-definitions.html#packagings). +type members, as well as for [top-level objects](09-top-level-definitions.html#packagings). ### Example The following code defines an abstract class of monoids and @@ -62,13 +62,13 @@ call without a prefix and that denote an or an implicit parameter. An eligible identifier may thus be a local name, or a member of an enclosing template, or it may be have been made accessible without a prefix -through an [import clause](06-basic-declarations-and-definitions.html#import-clauses). If there are no eligible +through an [import clause](04-basic-declarations-and-definitions.html#import-clauses). If there are no eligible identifiers under this rule, then, second, eligible are also all `implicit` members of some object that belongs to the implicit scope of the implicit parameter's type, $T$. -The _implicit scope_ of a type $T$ consists of all [companion modules](07-classes-and-objects.html#object-definitions) of classes that are associated with the implicit parameter's type. -Here, we say a class $C$ is _associated_ with a type $T$ if it is a [base class](07-classes-and-objects.html#class-linearization) of some part of $T$. +The _implicit scope_ of a type $T$ consists of all [companion modules](05-classes-and-objects.html#object-definitions) of classes that are associated with the implicit parameter's type. +Here, we say a class $C$ is _associated_ with a type $T$ if it is a [base class](05-classes-and-objects.html#class-linearization) of some part of $T$. The _parts_ of a type $T$ are: @@ -92,7 +92,7 @@ Thus, implicits defined in a package object are part of the implicit scope of a If there are several eligible arguments which match the implicit parameter's type, a most specific one will be chosen using the rules -of static [overloading resolution](08-expressions.html#overloading-resolution). +of static [overloading resolution](06-expressions.html#overloading-resolution). If the parameter has a default argument and no implicit argument can be found the default argument is used. @@ -119,7 +119,7 @@ be passed as implicit parameter. This discussion also shows that implicit parameters are inferred after -any type arguments are [inferred](08-expressions.html#local-type-inference). +any type arguments are [inferred](06-expressions.html#local-type-inference). Implicit methods can themselves have implicit parameters. An example is the following method from module `scala.List`, which injects @@ -182,8 +182,8 @@ To prevent such infinite expansions, the compiler keeps track of a stack of “open implicit types” for which implicit arguments are currently being searched. Whenever an implicit argument for type $T$ is searched, the “core type” of $T$ is added to the stack. Here, the _core type_ -of $T$ is $T$ with aliases expanded, top-level type [annotations](13-user-defined-annotations.html#user-defined-annotations) and -[refinements](05-types.html#compound-types) removed, and occurrences +of $T$ is $T$ with aliases expanded, top-level type [annotations](11-user-defined-annotations.html#user-defined-annotations) and +[refinements](03-types.html#compound-types) removed, and occurrences of top-level existentially bound variables replaced by their upper bounds. The core type is removed from the stack once the search for the implicit argument either definitely fails or succeeds. Everytime a @@ -191,7 +191,7 @@ core type is added to the stack, it is checked that this type does not dominate any of the other types in the set. Here, a core type $T$ _dominates_ a type $U$ if $T$ is -[equivalent](05-types.html#type-equivalence) +[equivalent](03-types.html#type-equivalence) to $U$, or if the top-level type constructors of $T$ and $U$ have a common element and $T$ is more complex than $U$. @@ -433,7 +433,7 @@ Then the following rules apply. `Manifest.intersectionType[T]($ms$)` where $ms$ are the manifests determined for $M[T_1] , \ldots , M[T_n]$. Otherwise, if $M$ is trait `ClassManifest`, - then a manifest is generated for the [intersection dominator](05-types.html#type-erasure) + then a manifest is generated for the [intersection dominator](03-types.html#type-erasure) of the types $T_1 , \ldots , T_n$. 1. If $T$ is some other type, then if $M$ is trait `OptManifest`, a manifest is generated from the designator `scala.reflect.NoManifest`. diff --git a/spec/10-pattern-matching.md b/spec/08-pattern-matching.md similarity index 97% rename from spec/10-pattern-matching.md rename to spec/08-pattern-matching.md index 19182c757b47..7b4d070181e7 100644 --- a/spec/10-pattern-matching.md +++ b/spec/08-pattern-matching.md @@ -109,10 +109,10 @@ expected type of the pattern. SimplePattern ::= StableId ``` -A stable identifier pattern is a [stable identifier](05-types.html#paths) $r$. +A stable identifier pattern is a [stable identifier](03-types.html#paths) $r$. The type of $r$ must conform to the expected type of the pattern. The pattern matches any value $v$ such that -`$r$ == $v$` (see [here](14-the-scala-standard-library.html#root-classes)). +`$r$ == $v$` (see [here](12-the-scala-standard-library.html#root-classes)). To resolve the syntactic overlap with a variable pattern, a stable identifier pattern may not be a simple name starting with a lower-case @@ -151,10 +151,10 @@ SimplePattern ::= StableId `(' [Patterns] `) A constructor pattern is of the form $c(p_1 , \ldots , p_n)$ where $n \geq 0$. It consists of a stable identifier $c$, followed by element patterns $p_1 , \ldots , p_n$. The constructor $c$ is a simple or -qualified name which denotes a [case class](07-classes-and-objects.html#case-classes). +qualified name which denotes a [case class](05-classes-and-objects.html#case-classes). If the case class is monomorphic, then it must conform to the expected type of the pattern, and the formal -parameter types of $x$'s [primary constructor](07-classes-and-objects.html#class-definitions) +parameter types of $x$'s [primary constructor](05-classes-and-objects.html#class-definitions) are taken as the expected types of the element patterns $p_1, \ldots , p_n$. If the case class is polymorphic, then its type parameters are instantiated so that the instantiation of $c$ conforms to the expected @@ -246,7 +246,7 @@ SimplePattern ::= StableId `(' [Patterns `,'] [varid `@'] `_' `*' `)' ``` A pattern sequence $p_1 , \ldots , p_n$ appears in two contexts. -First, in a constructor pattern $c(q_1 , \ldots , q_m, p_1 , \ldots , p_n)$, where $c$ is a case class which has $m+1$ primary constructor parameters, ending in a [repeated parameter](06-basic-declarations-and-definitions.html#repeated-parameters) of type `S*`. +First, in a constructor pattern $c(q_1 , \ldots , q_m, p_1 , \ldots , p_n)$, where $c$ is a case class which has $m+1$ primary constructor parameters, ending in a [repeated parameter](04-basic-declarations-and-definitions.html#repeated-parameters) of type `S*`. Second, in an extractor pattern $x(q_1 , \ldots , q_m, p_1 , \ldots , p_n)$ if the extractor object $x$ does not have an `unapply` method, but it does define an `unapplySeq` method with a result type conforming to `Option[(T_1, ... , T_m, Seq[S])]` (if `m = 0`, the type `Option[Seq[S]]` is also accepted). The expected type for the patterns $p_i$ is $S$. @@ -269,7 +269,7 @@ p_n$. An infix operation pattern $p;\mathit{op};q$ is a shorthand for the constructor or extractor pattern $\mathit{op}(p, q)$. The precedence and associativity of operators in patterns is the same as in -[expressions](08-expressions.html#prefix-infix-and-postfix-operations). +[expressions](06-expressions.html#prefix-infix-and-postfix-operations). An infix operation pattern $p;\mathit{op};(q_1 , \ldots , q_n)$ is a shorthand for the constructor or extractor pattern $\mathit{op}(p, q_1 @@ -289,7 +289,7 @@ matches a value $v$ if at least one its alternatives matches $v$. ### XML Patterns -XML patterns are treated [here](12-xml-expressions-and-patterns.html#xml-patterns). +XML patterns are treated [here](10-xml-expressions-and-patterns.html#xml-patterns). ### Regular Expression Patterns @@ -314,7 +314,7 @@ A pattern $p$ is _irrefutable_ for a type $T$, if one of the following applies: 1. $p$ is a variable pattern, 1. $p$ is a typed pattern $x: T'$, and $T <: T'$, 1. $p$ is a constructor pattern $c(p_1 , \ldots , p_n)$, the type $T$ - is an instance of class $c$, the [primary constructor](07-classes-and-objects.html#class-definitions) + is an instance of class $c$, the [primary constructor](05-classes-and-objects.html#class-definitions) of type $T$ has argument types $T_1 , \ldots , T_n$, and each $p_i$ is irrefutable for $T_i$. @@ -359,7 +359,7 @@ A type pattern $T$ is of one of the following forms: Types which are not of one of the forms described above are also accepted as type patterns. However, such type patterns will be translated to their -[erasure](05-types.html#type-erasure). The Scala +[erasure](03-types.html#type-erasure). The Scala compiler will issue an "unchecked" warning for these patterns to flag the possible loss of type-safety. @@ -486,7 +486,7 @@ x match { Scala does not maintain information about type arguments at run-time, so there is no way to check that `x` is a list of strings. -Instead, the Scala compiler will [erase](05-types.html#type-erasure) the +Instead, the Scala compiler will [erase](03-types.html#type-erasure) the pattern to `List[_]`; that is, it will only test whether the top-level runtime-class of the value `x` conforms to `List`, and the pattern match will succeed if it does. This @@ -565,7 +565,7 @@ instead of $L_i$ and has upper bound $U'_i$ instead of $U_i$. The expected type of every block $b_i$ is the expected type of the whole pattern matching expression. The type of the pattern matching -expression is then the [weak least upper bound](05-types.html#weak-conformance) +expression is then the [weak least upper bound](03-types.html#weak-conformance) of the types of all blocks $b_i$. @@ -592,7 +592,7 @@ side effects in guards. However, it is guaranteed that a guard expression is evaluated only if the pattern it guards matches. If the selector of a pattern match is an instance of a -[`sealed` class](07-classes-and-objects.html#modifiers), +[`sealed` class](05-classes-and-objects.html#modifiers), the compilation of pattern matching can emit warnings which diagnose that a given set of patterns is not exhaustive, i.e. that there is a possibility of a `MatchError` being raised at run-time. @@ -667,7 +667,7 @@ the expression is taken to be equivalent to the anonymous function: ``` Here, each $x_i$ is a fresh name. -As was shown [here](08-expressions.html#anonymous-functions), this anonymous function is in turn +As was shown [here](06-expressions.html#anonymous-functions), this anonymous function is in turn equivalent to the following instance creation expression, where $T$ is the weak least upper bound of the types of all $b_i$. diff --git a/spec/11-top-level-definitions.md b/spec/09-top-level-definitions.md similarity index 98% rename from spec/11-top-level-definitions.md rename to spec/09-top-level-definitions.md index cfb2c98adbfb..b9c78b23a162 100644 --- a/spec/11-top-level-definitions.md +++ b/spec/09-top-level-definitions.md @@ -47,7 +47,7 @@ package $p_1$ { $\ldots$ Every compilation unit implicitly imports the following packages, in the given order: 1. the package `java.lang`, 2. the package `scala`, and - 3. the object [`scala.Predef`](14-the-scala-standard-library.html#the-predef-object), unless there is an explicit top-level import that references `scala.Predef`. + 3. the object [`scala.Predef`](12-the-scala-standard-library.html#the-predef-object), unless there is an explicit top-level import that references `scala.Predef`. Members of a later import in that order hide members of an earlier import. diff --git a/spec/12-xml-expressions-and-patterns.md b/spec/10-xml-expressions-and-patterns.md similarity index 96% rename from spec/12-xml-expressions-and-patterns.md rename to spec/10-xml-expressions-and-patterns.md index 7aab3380d49a..d8c45ecf85d0 100644 --- a/spec/12-xml-expressions-and-patterns.md +++ b/spec/10-xml-expressions-and-patterns.md @@ -16,7 +16,7 @@ changes being mandated by the possibility of embedding Scala code fragments. XML expressions are expressions generated by the following production, where the opening bracket `<` of the first element must be in a position to start the lexical -[XML mode](03-lexical-syntax.html#xml-mode). +[XML mode](01-lexical-syntax.html#xml-mode). ```ebnf XmlExpr ::= XmlContent {Element} @@ -107,7 +107,7 @@ XNameStart ::= ‘_’ | BaseChar | Ideographic XML patterns are patterns generated by the following production, where the opening bracket `<` of the element patterns must be in a position -to start the lexical [XML mode](03-lexical-syntax.html#xml-mode). +to start the lexical [XML mode](01-lexical-syntax.html#xml-mode). ```ebnf XmlPattern ::= ElementPattern @@ -119,7 +119,7 @@ An XML pattern has to be a single element pattern. It matches exactly those runtime representations of an XML tree that have the same structure as described by the pattern. -XML patterns may contain [Scala patterns](10-pattern-matching.html#pattern-matching-expressions). +XML patterns may contain [Scala patterns](08-pattern-matching.html#pattern-matching-expressions). Whitespace is treated the same way as in XML expressions. diff --git a/spec/13-user-defined-annotations.md b/spec/11-user-defined-annotations.md similarity index 99% rename from spec/13-user-defined-annotations.md rename to spec/11-user-defined-annotations.md index 1e631a7ccf3e..fd7a7f9d3fd9 100644 --- a/spec/13-user-defined-annotations.md +++ b/spec/11-user-defined-annotations.md @@ -105,7 +105,7 @@ Java platform, the following annotations have a standard meaning. warning because `Option` is a `sealed` class. * `@uncheckedStable` When applied a value declaration or definition, it allows the defined - value to appear in a path, even if its type is [volatile](05-types.html#volatile-types). + value to appear in a path, even if its type is [volatile](03-types.html#volatile-types). For instance, the following member definitions are legal: ``` diff --git a/spec/14-the-scala-standard-library.md b/spec/12-the-scala-standard-library.md similarity index 98% rename from spec/14-the-scala-standard-library.md rename to spec/12-the-scala-standard-library.md index 4b79fd328514..8868d6e17a2a 100644 --- a/spec/14-the-scala-standard-library.md +++ b/spec/12-the-scala-standard-library.md @@ -140,12 +140,12 @@ Byte - Short `Byte` and `Short` are the lowest-ranked types in this order, whereas `Double` is the highest-ranked. Ranking does _not_ -imply a [conformance relationship](05-types.html#conformance); for +imply a [conformance relationship](03-types.html#conformance); for instance `Int` is not a subtype of `Long`. However, object -[`Predef`](#the-predef-object) defines [views](09-implicit-parameters-and-views.html#views) +[`Predef`](#the-predef-object) defines [views](07-implicit-parameters-and-views.html#views) from every numeric value type to all higher-ranked numeric value types. Therefore, lower-ranked types are implicitly converted to higher-ranked types -when required by the [context](08-expressions.html#implicit-conversions). +when required by the [context](06-expressions.html#implicit-conversions). Given two numeric value types $S$ and $T$, the _operation type_ of $S$ and $T$ is defined as follows: If both $S$ and $T$ are subrange @@ -470,7 +470,7 @@ val ys: Array[Object] = xs.asInstanceOf[Array[Object]] // OK The instantiation of an array with a polymorphic element type $T$ requires information about type $T$ at runtime. -This information is synthesized by adding a [context bound](09-implicit-parameters-and-views.html#context-bounds-and-view-bounds) +This information is synthesized by adding a [context bound](07-implicit-parameters-and-views.html#context-bounds-and-view-bounds) of `scala.reflect.ClassTag` to type $T$. An example is the following implementation of method `mkArray`, which creates @@ -501,7 +501,7 @@ will return a primitive array of `int`s, written as `int[]` in Java. `Array`'s companion object provides various factory methods for the instantiation of single- and multi-dimensional arrays, an extractor method -[`unapplySeq`](10-pattern-matching.html#extractor-patterns) which enables pattern matching +[`unapplySeq`](08-pattern-matching.html#extractor-patterns) which enables pattern matching over arrays and additional utility methods: ```scala @@ -761,7 +761,7 @@ object Predef { The `Predef` object also contains a number of implicit definitions, which are available by default (because `Predef` is implicitly imported). Implicit definitions come in two priorities. High-priority implicits are defined in the `Predef` class itself whereas low priority implicits are defined in a class inherited by `Predef`. The rules of -static [overloading resolution](08-expressions.html#overloading-resolution) +static [overloading resolution](06-expressions.html#overloading-resolution) stipulate that, all other things being equal, implicit resolution prefers high-priority implicits over low-priority ones. diff --git a/spec/15-syntax-summary.md b/spec/13-syntax-summary.md similarity index 100% rename from spec/15-syntax-summary.md rename to spec/13-syntax-summary.md diff --git a/spec/16-references.md b/spec/14-references.md similarity index 100% rename from spec/16-references.md rename to spec/14-references.md diff --git a/spec/_layouts/toc.yml b/spec/_layouts/toc.yml new file mode 100644 index 000000000000..d77ea62a19f1 --- /dev/null +++ b/spec/_layouts/toc.yml @@ -0,0 +1,15 @@ + + + + + + + + + + + +{{ content }} + + + \ No newline at end of file diff --git a/spec/index.md b/spec/index.md index 3cadbdee8338..22209b42629c 100644 --- a/spec/index.md +++ b/spec/index.md @@ -1,14 +1,71 @@ --- title: Scala Language Reference -layout: default +layout: toc --- - + + + +## Preface + +Scala is a Java-like programming language which unifies +object-oriented and functional programming. It is a pure +object-oriented language in the sense that every value is an +object. Types and behavior of objects are described by +classes. Classes can be composed using mixin composition. Scala is +designed to work seamlessly with two less pure but mainstream +object-oriented languages – Java and C#. + +Scala is a functional language in the sense that every function is a +value. Nesting of function definitions and higher-order functions are +naturally supported. Scala also supports a general notion of pattern +matching which can model the algebraic types used in many functional +languages. + +Scala has been designed to interoperate seamlessly with Java. +Scala classes can call Java methods, create Java objects, inherit from Java +classes and implement Java interfaces. None of this requires interface +definitions or glue code. + +Scala has been developed from 2001 in the programming methods +laboratory at EPFL. Version 1.0 was released in November 2003. This +document describes the second version of the language, which was +released in March 2006. It acts a reference for the language +definition and some core library modules. It is not intended to teach +Scala or its concepts; for this there are [other documents](14-references.html). + +Scala has been a collective effort of many people. The design and the +implementation of version 1.0 was completed by Philippe Altherr, +Vincent Cremet, Gilles Dubochet, Burak Emir, Stéphane Micheloud, +Nikolay Mihaylov, Michel Schinz, Erik Stenman, Matthias Zenger, and +the author. Iulian Dragos, Gilles Dubochet, Philipp Haller, Sean +McDirmid, Lex Spoon, and Geoffrey Washburn joined in the effort to +develop the second version of the language and tools. Gilad Bracha, +Craig Chambers, Erik Ernst, Matthias Felleisen, Shriram Krishnamurti, +Gary Leavens, Sebastian Maneth, Erik Meijer, Klaus Ostermann, Didier +Rémy, Mads Torgersen, and Philip Wadler have shaped the design of +the language through lively and inspiring discussions and comments on +previous versions of this document. The contributors to the Scala +mailing list have also given very useful feedback that helped us +improve the language and its tools. From a89157f9a0170e98f64ba2927e50cfbf1ece697c Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Fri, 28 Mar 2014 16:56:24 -0700 Subject: [PATCH 171/826] Stubs for references chapter, remains TODO --- spec/14-references.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/spec/14-references.md b/spec/14-references.md index a16176c6515a..8c169b9ea4a3 100644 --- a/spec/14-references.md +++ b/spec/14-references.md @@ -7,8 +7,22 @@ chapter: 14 # References +TODO (see comments in markdown source) + ") + } } diff --git a/test/files/scalacheck/quasiquotes/UnliftableProps.scala b/test/files/scalacheck/quasiquotes/UnliftableProps.scala index 1d7629aa29c8..659b18edabb1 100644 --- a/test/files/scalacheck/quasiquotes/UnliftableProps.scala +++ b/test/files/scalacheck/quasiquotes/UnliftableProps.scala @@ -155,4 +155,12 @@ object UnliftableProps extends QuasiquoteProperties("unliftable") { assert(t21 == (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)) assert(t22 == (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)) } + + property("unlift xml comment") = test { + implicit val unliftXmlComment = Unliftable[xml.Comment] { + case q"new _root_.scala.xml.Comment(${value: String})" => xml.Comment(value) + } + val q"${comment: xml.Comment}" = q"" + assert(comment.commentText == "foo") + } } From 2ba045368cf039cade862b8d4141d03659eb5bd8 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Thu, 3 Apr 2014 11:39:32 +0200 Subject: [PATCH 186/826] Further tweak version of continuations plugin in scala-dist.pom While we must use full version, rather than the cross version (12720e699), we need to use latest non-snapshot version. This should avoid failures like: https://jenkins.scala-ide.org:8496/jenkins/view/Scala%20Xsource%20flag%20nightlies/job/Akka/63/console Such as: [warn] :::::::::::::::::::::::::::::::::::::::::::::: [warn] :: UNRESOLVED DEPENDENCIES :: [warn] :::::::::::::::::::::::::::::::::::::::::::::: [warn] :: org.scala-lang.plugins#scala-continuations-plugin_2.11.0-SNAPSHOT;1.0.1: not found [warn] :::::::::::::::::::::::::::::::::::::::::::::: sbt.ResolveException: unresolved dependency: org.scala-lang.plugins#scala-continuations-plugin_2.11.0-SNAPSHOT;1.0.1: --- build-ant-macros.xml | 2 ++ src/build/maven/scala-dist-pom.xml | 3 ++- versions.properties | 4 ++++ 3 files changed, 8 insertions(+), 1 deletion(-) diff --git a/build-ant-macros.xml b/build-ant-macros.xml index b90102538b46..816a18b13fe5 100644 --- a/build-ant-macros.xml +++ b/build-ant-macros.xml @@ -432,6 +432,7 @@ + @@ -554,6 +555,7 @@ + diff --git a/src/build/maven/scala-dist-pom.xml b/src/build/maven/scala-dist-pom.xml index 83ebc263c033..22a24dea2152 100644 --- a/src/build/maven/scala-dist-pom.xml +++ b/src/build/maven/scala-dist-pom.xml @@ -41,7 +41,8 @@ org.scala-lang.plugins - scala-continuations-plugin_@VERSION@ + + scala-continuations-plugin_@SCALA_FULL_VERSION@ @CONTINUATIONS_PLUGIN_VERSION@ + From 2d37cc0b846a0ba50eb534c2a7379efd95f72ebc Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Mon, 21 Apr 2014 23:39:16 +0300 Subject: [PATCH 201/826] makes bundles friendly to -Ywarn-dead-code Apparently, the `new Bundle(???).impl` synthetic tree generated as a macro impl ref for bundles evokes -Ywarn-dead-code warnings. This pull requests changes `???` to `null` in order not to stress out the checker. What's in the argument doesn't actually make any difference anyway. --- .../reflect/macros/compiler/DefaultMacroCompiler.scala | 2 +- test/files/pos/t8523.flags | 1 + test/files/pos/t8523.scala | 10 ++++++++++ 3 files changed, 12 insertions(+), 1 deletion(-) create mode 100644 test/files/pos/t8523.flags create mode 100644 test/files/pos/t8523.scala diff --git a/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala b/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala index 1413065a2760..a13a778b2f32 100644 --- a/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala +++ b/src/compiler/scala/reflect/macros/compiler/DefaultMacroCompiler.scala @@ -53,7 +53,7 @@ abstract class DefaultMacroCompiler extends Resolvers (EmptyTree, TermName(""), Nil) } val bundleImplRef = MacroImplRefCompiler( - atPos(macroDdef.rhs.pos)(gen.mkTypeApply(Select(New(maybeBundleRef, List(List(Ident(Predef_???)))), methName), targs)), + atPos(macroDdef.rhs.pos)(gen.mkTypeApply(Select(New(maybeBundleRef, List(List(Literal(Constant(null))))), methName), targs)), isImplBundle = true ) val vanillaResult = tryCompile(vanillaImplRef) diff --git a/test/files/pos/t8523.flags b/test/files/pos/t8523.flags new file mode 100644 index 000000000000..c7d406c649e8 --- /dev/null +++ b/test/files/pos/t8523.flags @@ -0,0 +1 @@ +-Ywarn-dead-code -Xfatal-warnings \ No newline at end of file diff --git a/test/files/pos/t8523.scala b/test/files/pos/t8523.scala new file mode 100644 index 000000000000..dfcb35404df8 --- /dev/null +++ b/test/files/pos/t8523.scala @@ -0,0 +1,10 @@ +import scala.language.experimental.macros +import scala.reflect.macros.blackbox.Context + +class Impl(val c: Context) { + def impl: c.Tree = ??? +} + +object Macros { + def foo: Any = macro Impl.impl +} \ No newline at end of file From ecdc4415c77271e4743066e769342d0577a7d9b4 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Wed, 23 Apr 2014 08:15:01 +0200 Subject: [PATCH 202/826] SI-8478 Fix a performance regression in subtyping When checking `M[X] <:< M[Y]` for an `M` with an invariant parameter, we have to check that `X <:< Y && Y <:< X`. This is done in `isSubArgs`. The compile time of that program in the ticket jumps from 20s in 2.10.4 to too-long-to-measure in 2.11.0. This commit reverts the a subtle change to `isSubArgs` in ea93654 that was ultimately responsible. The search for this was unusually circuitious, even for scalac. It appeared in 9c09c1709 due a tiny error that has since been reverted in 58bfa19. But 58bfa19 still exhibited abysmal performance, due to an intervening regression that I'm targeting here. I haven't managed to extract a performance test from Slick. Using the test that @cvogt provided, however, with this patch: % time qbin/scalac -J-Xmx4G -classpath /Users/jason/code/slick-presentation/target/scala-2.10/classes:/Users/jason/.sbt/0.13/staging/b64b71d1228cdfe7b6d8/slick/target/scala-2.10/classes:/Users/jason/.ivy2/cache/org.slf4j/slf4j-api/jars/slf4j-api-1.6.4.jar /Users/jason/code/slick-presentation/src/main/scala/SlickPresentation.scala real 0m21.853s user 0m33.625s sys 0m0.878s Which is back to 2.10.x style performance. --- src/reflect/scala/reflect/internal/Types.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala index eb56f4ba81e1..f26315c5389c 100644 --- a/src/reflect/scala/reflect/internal/Types.scala +++ b/src/reflect/scala/reflect/internal/Types.scala @@ -4113,8 +4113,8 @@ trait Types def isSubArgs(tps1: List[Type], tps2: List[Type], tparams: List[Symbol], depth: Depth): Boolean = { def isSubArg(t1: Type, t2: Type, variance: Variance) = ( - (variance.isContravariant || isSubType(t1, t2, depth)) - && (variance.isCovariant || isSubType(t2, t1, depth)) + (variance.isCovariant || isSubType(t2, t1, depth)) // The order of these two checks can be material for performance (SI-8478) + && (variance.isContravariant || isSubType(t1, t2, depth)) ) corresponds3(tps1, tps2, mapList(tparams)(_.variance))(isSubArg) From 7d57e248db9cbc444f83de669ed78102bceaaff1 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 24 Apr 2014 09:50:16 -0700 Subject: [PATCH 203/826] Restore linking to source from scaladoc. Somehow the `docsourceurl` param got dropped in the build refactor. --- build-ant-macros.xml | 36 ++++++++++++++++++++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-) diff --git a/build-ant-macros.xml b/build-ant-macros.xml index 816a18b13fe5..ea5652770e1e 100644 --- a/build-ant-macros.xml +++ b/build-ant-macros.xml @@ -408,12 +408,44 @@ - + - + From c13f5a41a0e09add04eabbe9769e916ee22eccd8 Mon Sep 17 00:00:00 2001 From: Grzegorz Kossakowski Date: Fri, 25 Apr 2014 13:41:33 +0200 Subject: [PATCH 204/826] Use named class for UndoPair. Use specific, named class for UndoPair instead of generic Tuple2. This makes analysis of heap dumps much easier because profilers let you inspect memory consumption on per-class basis. The UndoPair case class is defined in companion object to not hold an outer pointer reference. --- .../reflect/internal/tpe/TypeConstraints.scala | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala b/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala index 564cbb1ce3ab..c1c43178e519 100644 --- a/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala +++ b/src/reflect/scala/reflect/internal/tpe/TypeConstraints.scala @@ -16,8 +16,9 @@ private[internal] trait TypeConstraints { private lazy val _undoLog = new UndoLog def undoLog = _undoLog + import TypeConstraints.UndoPair class UndoLog extends Clearable { - private type UndoPairs = List[(TypeVar, TypeConstraint)] + type UndoPairs = List[UndoPair[TypeVar, TypeConstraint]] //OPT this method is public so we can do `manual inlining` var log: UndoPairs = List() @@ -29,7 +30,7 @@ private[internal] trait TypeConstraints { def undoTo(limit: UndoPairs) { assertCorrectThread() while ((log ne limit) && log.nonEmpty) { - val (tv, constr) = log.head + val UndoPair(tv, constr) = log.head tv.constr = constr log = log.tail } @@ -40,7 +41,7 @@ private[internal] trait TypeConstraints { * which is already synchronized. */ private[reflect] def record(tv: TypeVar) = { - log ::= ((tv, tv.constr.cloneInternal)) + log ::= UndoPair(tv, tv.constr.cloneInternal) } def clear() { @@ -266,3 +267,9 @@ private[internal] trait TypeConstraints { tvars forall (tv => tv.instWithinBounds || util.andFalse(logBounds(tv))) } } + +private[internal] object TypeConstraints { + // UndoPair is declared in companion object to not hold an outer pointer reference + final case class UndoPair[TypeVar <: SymbolTable#TypeVar, + TypeConstraint <: TypeConstraints#TypeConstraint](tv: TypeVar, tConstraint: TypeConstraint) +} From 8317266f34dce29078dc7c4447605701ba82e82a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Garillot?= Date: Fri, 25 Apr 2014 15:52:50 +0200 Subject: [PATCH 205/826] SI-8537 Puts SI-8157 fix under Xsource --- .../scala/tools/nsc/typechecker/RefChecks.scala | 11 ++++++++++- test/files/pos/t8157-2.10.flags | 1 + test/files/pos/t8157-2.10.scala | 5 +++++ 3 files changed, 16 insertions(+), 1 deletion(-) create mode 100644 test/files/pos/t8157-2.10.flags create mode 100644 test/files/pos/t8157-2.10.scala diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index b166bf988d4b..4540017b62b0 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -132,7 +132,16 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans defaultMethodNames.toList.distinct foreach { name => val methods = clazz.info.findMember(name, 0L, requiredFlags = METHOD, stableOnly = false).alternatives - val haveDefaults = methods filter (sym => mexists(sym.info.paramss)(_.hasDefault) && !nme.isProtectedAccessorName(sym.name)) + def hasDefaultParam(tpe: Type): Boolean = tpe match { + case MethodType(params, restpe) => (params exists (_.hasDefault)) || hasDefaultParam(restpe) + case _ => false + } + val haveDefaults = methods filter ( + if (settings.isScala211) + (sym => mexists(sym.info.paramss)(_.hasDefault) && !nme.isProtectedAccessorName(sym.name)) + else + (sym => hasDefaultParam(sym.info) && !nme.isProtectedAccessorName(sym.name)) + ) if (haveDefaults.lengthCompare(1) > 0) { val owners = haveDefaults map (_.owner) diff --git a/test/files/pos/t8157-2.10.flags b/test/files/pos/t8157-2.10.flags new file mode 100644 index 000000000000..94c80567477b --- /dev/null +++ b/test/files/pos/t8157-2.10.flags @@ -0,0 +1 @@ +-Xsource:2.10 diff --git a/test/files/pos/t8157-2.10.scala b/test/files/pos/t8157-2.10.scala new file mode 100644 index 000000000000..597585a96d32 --- /dev/null +++ b/test/files/pos/t8157-2.10.scala @@ -0,0 +1,5 @@ +object Test { // PolyTYped function default arg unicity check, + // fails in 2.11, authorized under -Xsource:2.10 + def foo(printer: Any, question: => String, show: Boolean = false)(op: => Any): Any = ??? + def foo[T](question: => String, show: Boolean)(op: => Any = ()): Any = ??? +} From c6b50282ab25c092af21b81080f863f8b44d08dc Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Tue, 29 Apr 2014 00:02:02 +0200 Subject: [PATCH 206/826] SI-8504 fix NPE in the Java wrapper for a Scala Map. MapWrapper blindly calls .hashCode on keys that can very well be null. --- src/library/scala/collection/convert/Wrappers.scala | 2 +- .../scala/collection/convert/MapWrapperTest.scala | 10 ++++++++++ 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/src/library/scala/collection/convert/Wrappers.scala b/src/library/scala/collection/convert/Wrappers.scala index 14ae57c43a03..7d1d6b3781d6 100644 --- a/src/library/scala/collection/convert/Wrappers.scala +++ b/src/library/scala/collection/convert/Wrappers.scala @@ -194,7 +194,7 @@ private[collection] trait Wrappers { def getKey = k def getValue = v def setValue(v1 : B) = self.put(k, v1) - override def hashCode = byteswap32(k.hashCode) + (byteswap32(v.hashCode) << 16) + override def hashCode = byteswap32(k.##) + (byteswap32(v.##) << 16) override def equals(other: Any) = other match { case e: ju.Map.Entry[_, _] => k == e.getKey && v == e.getValue case _ => false diff --git a/test/junit/scala/collection/convert/MapWrapperTest.scala b/test/junit/scala/collection/convert/MapWrapperTest.scala index 060b6b5937e2..22eaf858ea4a 100644 --- a/test/junit/scala/collection/convert/MapWrapperTest.scala +++ b/test/junit/scala/collection/convert/MapWrapperTest.scala @@ -46,4 +46,14 @@ class MapWrapperTest { assertFalse(javaMap.containsKey(null)) // negative test, null key assertEquals(4, scalaMap.containsCounter) } + + // test for SI-8504 + @Test + def testHashCode() { + import scala.collection.JavaConverters._ + val javaMap = Map(1 -> null).asJava + + // Before the fix for SI-8504, this throws a NPE + javaMap.hashCode + } } From 5679159827afbb34fac272d3b71824e43da2705c Mon Sep 17 00:00:00 2001 From: Tobias Roeser Date: Wed, 23 Apr 2014 19:35:01 +0200 Subject: [PATCH 207/826] Restrict Import-Package for scala.* Restrict the Import-Package OSGi manifest entry to match only binary compatible scala.* packages. This is necessary, because the Scala OSGi versions do not match the OSGi semantic versioning policy and are not binary compatible between their OSGi minor versions. This means that e.g. the scala-compiler-2.11 bundle will never work if it imports a scala.* package from 2.10 or 2.12. Thus this patch enforces a tight version range, only accepting versions within the same minor version. E.g. Applied to version 2.11.1 the range would expand to "[2.11,2.12)". Additionally, a Java 6 execution environment will be enforced for OSGi. All module bundles need to have their own version numbers. This was not the case before this commit. Although these module bundles were only build for testing, they are needed to be correct, now, that we have stricter package import constraints and some test cases rely on them. --- build-ant-macros.xml | 5 +++++ src/build/bnd/scala-actors.bnd | 2 ++ src/build/bnd/scala-compiler-doc.bnd | 4 +++- src/build/bnd/scala-compiler-interactive.bnd | 4 +++- src/build/bnd/scala-compiler.bnd | 5 +++++ src/build/bnd/scala-continuations-library.bnd | 5 ++++- src/build/bnd/scala-continuations-plugin.bnd | 5 ++++- src/build/bnd/scala-library.bnd | 2 ++ src/build/bnd/scala-parser-combinators.bnd | 5 ++++- src/build/bnd/scala-reflect.bnd | 6 +++++- src/build/bnd/scala-swing.bnd | 5 ++++- src/build/bnd/scala-xml.bnd | 5 ++++- 12 files changed, 45 insertions(+), 8 deletions(-) diff --git a/build-ant-macros.xml b/build-ant-macros.xml index 816a18b13fe5..383dba8aff55 100644 --- a/build-ant-macros.xml +++ b/build-ant-macros.xml @@ -435,6 +435,11 @@ + + + + + diff --git a/src/build/bnd/scala-actors.bnd b/src/build/bnd/scala-actors.bnd index 8d0555777ff7..ea0ac52145c3 100644 --- a/src/build/bnd/scala-actors.bnd +++ b/src/build/bnd/scala-actors.bnd @@ -3,3 +3,5 @@ Bundle-SymbolicName: org.scala-lang.scala-actors ver: @VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} +Import-Package: scala.*;version="${range;[==,=+);${ver}}",* +Bundle-RequiredExecutionEnvironment: JavaSE-1.6 diff --git a/src/build/bnd/scala-compiler-doc.bnd b/src/build/bnd/scala-compiler-doc.bnd index 4910e5fcb008..a68c938315f8 100644 --- a/src/build/bnd/scala-compiler-doc.bnd +++ b/src/build/bnd/scala-compiler-doc.bnd @@ -3,4 +3,6 @@ Bundle-SymbolicName: org.scala-lang.modules.scala-compiler-doc_@SCALA_BINARY_VER ver: @SCALA_COMPILER_DOC_VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} -Import-Package: * +Import-Package: scala.*;version="${range;[==,=+);@VERSION@}",* +Bundle-RequiredExecutionEnvironment: JavaSE-1.6 + diff --git a/src/build/bnd/scala-compiler-interactive.bnd b/src/build/bnd/scala-compiler-interactive.bnd index 34d2f2956d2d..8869aeb81105 100644 --- a/src/build/bnd/scala-compiler-interactive.bnd +++ b/src/build/bnd/scala-compiler-interactive.bnd @@ -3,4 +3,6 @@ Bundle-SymbolicName: org.scala-lang.modules.scala-compiler-interactive_@SCALA_BI ver: @SCALA_COMPILER_INTERACTIVE_VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} -Import-Package: * +Import-Package: scala.*;version="${range;[==,=+);@VERSION@}",* +Bundle-RequiredExecutionEnvironment: JavaSE-1.6 + diff --git a/src/build/bnd/scala-compiler.bnd b/src/build/bnd/scala-compiler.bnd index dc30513db407..98b743b2afc2 100644 --- a/src/build/bnd/scala-compiler.bnd +++ b/src/build/bnd/scala-compiler.bnd @@ -5,4 +5,9 @@ Bundle-Version: ${ver} Export-Package: *;version=${ver} Import-Package: jline.*;resolution:=optional, \ org.apache.tools.ant.*;resolution:=optional, \ + scala.util.parsing.*;version="${range;[===,=+);@PARSER_COMBINATORS_VERSION@}", \ + scala.xml.*;version="${range;[===,=+);@XML_VERSION@}", \ + scala.*;version="${range;[==,=+);${ver}}", \ * +Bundle-RequiredExecutionEnvironment: JavaSE-1.6 + diff --git a/src/build/bnd/scala-continuations-library.bnd b/src/build/bnd/scala-continuations-library.bnd index bb505b60a970..6d81973438bc 100644 --- a/src/build/bnd/scala-continuations-library.bnd +++ b/src/build/bnd/scala-continuations-library.bnd @@ -1,5 +1,8 @@ Bundle-Name: Scala Delimited Continuations Library Bundle-SymbolicName: org.scala-lang.plugins.scala-continuations-library -ver: @VERSION@ +ver: @CONTINUATIONS_LIBRARY_VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} +Import-Package: scala.*;version="${range;[==,=+);@VERSION@}",* +Bundle-RequiredExecutionEnvironment: JavaSE-1.6 + diff --git a/src/build/bnd/scala-continuations-plugin.bnd b/src/build/bnd/scala-continuations-plugin.bnd index cd66614a22c4..40ea2e85112b 100644 --- a/src/build/bnd/scala-continuations-plugin.bnd +++ b/src/build/bnd/scala-continuations-plugin.bnd @@ -1,5 +1,8 @@ Bundle-Name: Scala Delimited Continuations Compiler Plugin Bundle-SymbolicName: org.scala-lang.plugins.scala-continuations-plugin -ver: @VERSION@ +ver: @CONTINUATIONS_PLUGIN_VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} +Import-Package: scala.*;version="${range;[==,=+);@VERSION@}",* +Bundle-RequiredExecutionEnvironment: JavaSE-1.6 + diff --git a/src/build/bnd/scala-library.bnd b/src/build/bnd/scala-library.bnd index 03aff45672fe..ff78c5270111 100644 --- a/src/build/bnd/scala-library.bnd +++ b/src/build/bnd/scala-library.bnd @@ -4,3 +4,5 @@ ver: @VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} Import-Package: sun.misc;resolution:=optional, * +Bundle-RequiredExecutionEnvironment: JavaSE-1.6 + diff --git a/src/build/bnd/scala-parser-combinators.bnd b/src/build/bnd/scala-parser-combinators.bnd index 6ffc3b2760e1..bdaff5fb0d11 100644 --- a/src/build/bnd/scala-parser-combinators.bnd +++ b/src/build/bnd/scala-parser-combinators.bnd @@ -1,5 +1,8 @@ Bundle-Name: Scala Parser Combinators Library Bundle-SymbolicName: org.scala-lang.modules.scala-parser-combinators -ver: @VERSION@ +ver: @PARSER_COMBINATORS_VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} +Import-Package: scala.*;version="${range;[==,=+);@VERSION@}",* +Bundle-RequiredExecutionEnvironment: JavaSE-1.6 + diff --git a/src/build/bnd/scala-reflect.bnd b/src/build/bnd/scala-reflect.bnd index 6cda346d3ade..a8afca4af0b9 100644 --- a/src/build/bnd/scala-reflect.bnd +++ b/src/build/bnd/scala-reflect.bnd @@ -3,4 +3,8 @@ Bundle-SymbolicName: org.scala-lang.scala-reflect ver: @VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} -Import-Package: scala.tools.nsc;resolution:=optional, * +Import-Package: scala.*;version="${range;[==,=+);${ver}}", \ + scala.tools.nsc;resolution:=optional;version="${range;[==,=+);${ver}}", \ + * +Bundle-RequiredExecutionEnvironment: JavaSE-1.6 + diff --git a/src/build/bnd/scala-swing.bnd b/src/build/bnd/scala-swing.bnd index 7cccb1343bc5..62e198dc3466 100644 --- a/src/build/bnd/scala-swing.bnd +++ b/src/build/bnd/scala-swing.bnd @@ -1,5 +1,8 @@ Bundle-Name: Scala Swing Bundle-SymbolicName: org.scala-lang.modules.scala-swing -ver: @VERSION@ +ver: @SCALA_SWING_VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} +Import-Package: scala.*;version="${range;[==,=+);@VERSION@}",* +Bundle-RequiredExecutionEnvironment: JavaSE-1.6 + diff --git a/src/build/bnd/scala-xml.bnd b/src/build/bnd/scala-xml.bnd index 5d64c05e659c..2789b0e01c1d 100644 --- a/src/build/bnd/scala-xml.bnd +++ b/src/build/bnd/scala-xml.bnd @@ -1,5 +1,8 @@ Bundle-Name: Scala XML Library Bundle-SymbolicName: org.scala-lang.modules.scala-xml -ver: @VERSION@ +ver: @XML_VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} +Import-Package: scala.*;version="${range;[==,=+);@VERSION@}",* +Bundle-RequiredExecutionEnvironment: JavaSE-1.6 + From b3243e8d42871686a5c6c7b80e9874336a168795 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Wed, 30 Apr 2014 21:11:05 +0200 Subject: [PATCH 208/826] SI-8550 fix scaladoc for the default s.c.LinearSeq. The default LinearSeq is a List (LinearSeq.newBuilder delegates to immutable.LinearSeq.newBuilder, whose default is List). --- src/library/scala/collection/LinearSeq.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/library/scala/collection/LinearSeq.scala b/src/library/scala/collection/LinearSeq.scala index 1e4975a0a7a3..49fbb902abdf 100644 --- a/src/library/scala/collection/LinearSeq.scala +++ b/src/library/scala/collection/LinearSeq.scala @@ -25,7 +25,7 @@ trait LinearSeq[+A] extends Seq[A] } /** $factoryInfo - * The current default implementation of a $Coll is a `Vector`. + * The current default implementation of a $Coll is a `List`. * @define coll linear sequence * @define Coll `LinearSeq` */ From f93fbef8ecbcf1f09cd18632bd209dbf641f7c96 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Fri, 2 May 2014 10:21:56 +0200 Subject: [PATCH 209/826] IntelliJ project files Fixes compilation within IDEA. Allows compiling and running JUnit tests directly withing the IDE. --- build.xml | 3 +- src/intellij/README | 10 +++- src/intellij/actors.iml.SAMPLE | 3 +- src/intellij/compiler.iml.SAMPLE | 7 ++- src/intellij/interactive.iml.SAMPLE | 4 +- src/intellij/library.iml.SAMPLE | 5 +- src/intellij/manual.iml.SAMPLE | 5 +- src/intellij/partest-extras.iml.SAMPLE | 27 +++++++++ src/intellij/partest-javaagent.iml.SAMPLE | 13 ++++ src/intellij/reflect.iml.SAMPLE | 6 +- src/intellij/repl.iml.SAMPLE | 4 +- src/intellij/scala-lang.ipr.SAMPLE | 72 +++++++++++++---------- src/intellij/scaladoc.iml.SAMPLE | 9 +-- src/intellij/scalap.iml.SAMPLE | 3 +- src/intellij/setup.sh | 15 +---- src/intellij/test-junit.iml.SAMPLE | 30 ++++++++++ src/intellij/test.iml.SAMPLE | 22 +++++-- src/intellij/update.sh | 22 +++++++ 18 files changed, 188 insertions(+), 72 deletions(-) create mode 100644 src/intellij/partest-extras.iml.SAMPLE create mode 100644 src/intellij/partest-javaagent.iml.SAMPLE create mode 100644 src/intellij/test-junit.iml.SAMPLE create mode 100755 src/intellij/update.sh diff --git a/build.xml b/build.xml index 95ce2fe4e285..a66c138cbe32 100755 --- a/build.xml +++ b/build.xml @@ -368,12 +368,13 @@ TODO: - + + diff --git a/src/intellij/README b/src/intellij/README index ade87749cd07..a39691f4f066 100644 --- a/src/intellij/README +++ b/src/intellij/README @@ -1,8 +1,12 @@ Use the latest IntelliJ IDEA release and install the Scala plugin from within the IDE. +Compilation withing IDEA is performed in "-Dlocker.skip=1" mode: the sources are built +directly using the STARR compiler. + The following steps are required to use IntelliJ IDEA on Scala trunk - - compile "locker" using "ant locker.done". This will also download some JARs from - Maven to ./build/deps, which are included in IntelliJ's classpath. + - Run "ant init". This will download some JARs from to ./build/deps, which are + included in IntelliJ's classpath. - Run src/intellij/setup.sh - Open ./src/intellij/scala-lang.ipr in IntelliJ - - File, Project Settings, Project, SDK. Create an SDK entry named "1.6" containing the java 1.6 SDK + - File, Project Settings, Project, SDK. Create an SDK entry named "1.6" containing the + java 1.6 SDK diff --git a/src/intellij/actors.iml.SAMPLE b/src/intellij/actors.iml.SAMPLE index 896c4966ffd2..b15af8b11071 100644 --- a/src/intellij/actors.iml.SAMPLE +++ b/src/intellij/actors.iml.SAMPLE @@ -4,7 +4,8 @@ diff --git a/src/intellij/compiler.iml.SAMPLE b/src/intellij/compiler.iml.SAMPLE index 9fb9cd55eb14..50253000ab3c 100644 --- a/src/intellij/compiler.iml.SAMPLE +++ b/src/intellij/compiler.iml.SAMPLE @@ -4,7 +4,8 @@ @@ -19,8 +20,8 @@ - - + + diff --git a/src/intellij/interactive.iml.SAMPLE b/src/intellij/interactive.iml.SAMPLE index c6c8ebb60618..83178021d311 100644 --- a/src/intellij/interactive.iml.SAMPLE +++ b/src/intellij/interactive.iml.SAMPLE @@ -4,7 +4,8 @@ @@ -23,3 +24,4 @@ + diff --git a/src/intellij/library.iml.SAMPLE b/src/intellij/library.iml.SAMPLE index cac53dff15d2..137ce6eb9c04 100644 --- a/src/intellij/library.iml.SAMPLE +++ b/src/intellij/library.iml.SAMPLE @@ -4,8 +4,9 @@ diff --git a/src/intellij/manual.iml.SAMPLE b/src/intellij/manual.iml.SAMPLE index 3295a4a877a3..8babde73eab3 100644 --- a/src/intellij/manual.iml.SAMPLE +++ b/src/intellij/manual.iml.SAMPLE @@ -4,7 +4,8 @@ @@ -18,8 +19,8 @@ - + diff --git a/src/intellij/partest-extras.iml.SAMPLE b/src/intellij/partest-extras.iml.SAMPLE new file mode 100644 index 000000000000..c2ada43493e8 --- /dev/null +++ b/src/intellij/partest-extras.iml.SAMPLE @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/intellij/partest-javaagent.iml.SAMPLE b/src/intellij/partest-javaagent.iml.SAMPLE new file mode 100644 index 000000000000..e47e0f634940 --- /dev/null +++ b/src/intellij/partest-javaagent.iml.SAMPLE @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/src/intellij/reflect.iml.SAMPLE b/src/intellij/reflect.iml.SAMPLE index 7d1052282683..d206304896d3 100644 --- a/src/intellij/reflect.iml.SAMPLE +++ b/src/intellij/reflect.iml.SAMPLE @@ -4,8 +4,9 @@ @@ -19,7 +20,6 @@ - diff --git a/src/intellij/repl.iml.SAMPLE b/src/intellij/repl.iml.SAMPLE index fc78ffe8c231..83791f4f6e0f 100644 --- a/src/intellij/repl.iml.SAMPLE +++ b/src/intellij/repl.iml.SAMPLE @@ -4,7 +4,8 @@ @@ -23,3 +24,4 @@ + diff --git a/src/intellij/scala-lang.ipr.SAMPLE b/src/intellij/scala-lang.ipr.SAMPLE index a0765b3e99d3..c0614c946c44 100644 --- a/src/intellij/scala-lang.ipr.SAMPLE +++ b/src/intellij/scala-lang.ipr.SAMPLE @@ -1,8 +1,5 @@ - - - - - + + + + + + @@ -41,11 +40,16 @@ - @@ -234,45 +241,46 @@ - - - - - - - - - - - - - + - - + - - - + - - + - - - + + + - + + + + + + + + + + + + + + + + + + diff --git a/src/intellij/scaladoc.iml.SAMPLE b/src/intellij/scaladoc.iml.SAMPLE index 07bea5bf5d70..8f9a0d83443d 100644 --- a/src/intellij/scaladoc.iml.SAMPLE +++ b/src/intellij/scaladoc.iml.SAMPLE @@ -4,7 +4,8 @@ @@ -20,8 +21,8 @@ - - - + + + diff --git a/src/intellij/scalap.iml.SAMPLE b/src/intellij/scalap.iml.SAMPLE index 77eea7c38f8f..27ae45136978 100644 --- a/src/intellij/scalap.iml.SAMPLE +++ b/src/intellij/scalap.iml.SAMPLE @@ -4,7 +4,8 @@ diff --git a/src/intellij/setup.sh b/src/intellij/setup.sh index bd324ba5bd63..ec303778edf7 100755 --- a/src/intellij/setup.sh +++ b/src/intellij/setup.sh @@ -5,19 +5,10 @@ set -e export SCRIPT_DIR="$( cd "$( dirname "$0" )" && pwd )" -export BASE="$( cd "$( dirname "$0" )"/../.. && pwd )" echo "About to delete .ipr and .iml files and replace with the .SAMPLE files. Press enter to continue or CTRL-C to cancel." read -(rm -f *.ipr *.iml 2>/dev/null) -for f in $(ls "$SCRIPT_DIR"/*.SAMPLE); do - NEW_FILE=`echo $f | perl -pe 's/.SAMPLE//'`; - - cp $f $NEW_FILE - - # IntelliJ doesn't process the "compilerOptions" setting for variable - # replacement. If it did, we would just use "$PROJECT_DIR$". Instead, - # we do this replacement ourselves. - perl -pi -e 's/\$BASE_DIR\$/$ENV{"BASE"}/g' $NEW_FILE - echo "Created $NEW_FILE" +for f in "$SCRIPT_DIR"/*.SAMPLE; do + g=${f%.SAMPLE} + cp $f $g done diff --git a/src/intellij/test-junit.iml.SAMPLE b/src/intellij/test-junit.iml.SAMPLE new file mode 100644 index 000000000000..bb51c30a4f6b --- /dev/null +++ b/src/intellij/test-junit.iml.SAMPLE @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/intellij/test.iml.SAMPLE b/src/intellij/test.iml.SAMPLE index 423be2062c8b..cb4a8568a17e 100644 --- a/src/intellij/test.iml.SAMPLE +++ b/src/intellij/test.iml.SAMPLE @@ -1,21 +1,31 @@ + + + + + + - + + + - - + - - - + + + diff --git a/src/intellij/update.sh b/src/intellij/update.sh new file mode 100755 index 000000000000..eb6fea782f37 --- /dev/null +++ b/src/intellij/update.sh @@ -0,0 +1,22 @@ +#!/usr/bin/env bash +# +# Updates the .SAMPLE files with the current project files. +# + +set -e +export SCRIPT_DIR="$( cd "$( dirname "$0" )" && pwd )" + +echo "About to create overwrite the .ipr.SAMPLE and .iml.SAMPLE files with the current project files. Press enter to continue or CTRL-C to cancel." +read + +for f in "$SCRIPT_DIR"/*.{iml,ipr}; do + cp $f $f.SAMPLE +done + +for f in "$SCRIPT_DIR"/*.SAMPLE; do + g=${f%.SAMPLE} + if [[ ! -f $g ]]; then + echo "Stale sample file, deleting $f" + rm $f + fi +done From ecbc9d02153e9ad3a710c7c2c0f385797b1ba3a6 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Mon, 5 May 2014 11:32:43 +0200 Subject: [PATCH 210/826] SI-8549 Honour the @SerialVersionUID annotatation In PR #1673 / 4267444, the annotation `SerialVersionId` was changed from a `StaticAnnotation` to `ClassFileAnnotation` in order to avoid silently ignoring non-literal UIDs like: @SerialVersionUID(0 - 12345L) class C And to flag non-constant UIDs: @SerialVersionUID("!!!".length) While this indeed was fold constants, the change was incomplete. The compiler API for reading the argument from a `ClassFileAnnoation` is different, on must look for a `LiteralAnnotArg`, rather than a `Literal`. This commit: - amends the backend accordingly - removes relevant duplication between `GenASM` and `GenBCode` - tests that the static field is generated accordingly This will mean that we will break deserialization of objects from Scalal 2.11.0 that use this annotation. --- .../tools/nsc/backend/jvm/BCodeHelpers.scala | 14 +++++++------- .../scala/tools/nsc/backend/jvm/GenASM.scala | 4 +--- test/files/run/t8549b.scala | 16 ++++++++++++++++ 3 files changed, 24 insertions(+), 10 deletions(-) create mode 100644 test/files/run/t8549b.scala diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala index 359e5d6c2931..f800dbf9cd69 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala @@ -238,6 +238,13 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { cd.impl.body collect { case dd: DefDef => dd.symbol } } + /* + * must-single-thread + */ + def serialVUID(csym: Symbol): Option[Long] = csym getAnnotation definitions.SerialVersionUIDAttr collect { + case AnnotationInfo(_, _, (_, LiteralAnnotArg(const)) :: Nil) => const.longValue + } + /* * Populates the InnerClasses JVM attribute with `refedInnerClasses`. * In addition to inner classes mentioned somewhere in `jclass` (where `jclass` is a class file being emitted) @@ -880,13 +887,6 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { // The particular value in use for `MIN_SWITCH_DENSITY` reflects a heuristic. val MIN_SWITCH_DENSITY = 0.7 - /* - * must-single-thread - */ - def serialVUID(csym: Symbol): Option[Long] = csym getAnnotation definitions.SerialVersionUIDAttr collect { - case AnnotationInfo(_, Literal(const) :: _, _) => const.longValue - } - /* * Add public static final field serialVersionUID with value `id` * diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala index a389816caf33..b7f9b30e199e 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala @@ -1142,9 +1142,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { def isParcelableClass = isAndroidParcelableClass(clasz.symbol) - def serialVUID: Option[Long] = clasz.symbol getAnnotation SerialVersionUIDAttr collect { - case AnnotationInfo(_, Literal(const) :: _, _) => const.longValue - } + def serialVUID: Option[Long] = genBCode.serialVUID(clasz.symbol) private def getSuperInterfaces(c: IClass): Array[String] = { diff --git a/test/files/run/t8549b.scala b/test/files/run/t8549b.scala new file mode 100644 index 000000000000..1e1bf2c0bcb8 --- /dev/null +++ b/test/files/run/t8549b.scala @@ -0,0 +1,16 @@ + +@SerialVersionUID(42) +class C + +@SerialVersionUID(43 - 1) +class D + + +object Test extends App { + def checkId(cls: Class[_]) { + val id = cls.getDeclaredField("serialVersionUID").get(null) + assert(id == 42, (cls, id)) + } + checkId(classOf[C]) + checkId(classOf[D]) +} From b0fe13505faf7c93093b4e9dc2813259e2f70094 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Sun, 23 Feb 2014 02:37:09 -0800 Subject: [PATCH 211/826] SI-8325 Accept infix star type outside patterns This is a follow-up to SI-5702 which enabled use of `*` in infix notation in patterns. Most of the work is in distinguishing infix from a sequence pattern. Also, do not take backticked star as the repeated parameter marker in postfix position. That is, `Int``*``` is not `Int*` -- I hope double-tick renders as tick. There is not a special use case except that backticks mean "I am an identifier, as is, and not a keyword." --- .../scala/tools/nsc/ast/parser/Parsers.scala | 30 +++++++++++++------ test/files/neg/t8325-b.check | 10 +++++++ test/files/neg/t8325-b.scala | 4 +++ test/files/neg/t8325-c.check | 7 +++++ test/files/neg/t8325-c.scala | 4 +++ test/files/neg/t8325.check | 15 ++++++++++ test/files/neg/t8325.scala | 11 +++++++ test/files/pos/t8325.scala | 9 ++++++ 8 files changed, 81 insertions(+), 9 deletions(-) create mode 100644 test/files/neg/t8325-b.check create mode 100644 test/files/neg/t8325-b.scala create mode 100644 test/files/neg/t8325-c.check create mode 100644 test/files/neg/t8325-c.scala create mode 100644 test/files/neg/t8325.check create mode 100644 test/files/neg/t8325.scala create mode 100644 test/files/pos/t8325.scala diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index 9e631febeecf..ffc45b21ea40 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -654,9 +654,10 @@ self => def isIdentExcept(except: Name) = isIdent && in.name != except def isIdentOf(name: Name) = isIdent && in.name == name - def isUnaryOp = isIdent && raw.isUnary(in.name) - def isRawStar = isIdent && in.name == raw.STAR - def isRawBar = isIdent && in.name == raw.BAR + def isUnaryOp = isIdent && raw.isUnary(in.name) + def isRawStar = isRawIdent && in.name == raw.STAR + def isRawBar = isRawIdent && in.name == raw.BAR + def isRawIdent = in.token == IDENTIFIER def isIdent = in.token == IDENTIFIER || in.token == BACKQUOTED_IDENT def isMacro = in.token == IDENTIFIER && in.name == nme.MACROkw @@ -1001,19 +1002,30 @@ self => } def infixTypeRest(t: Tree, mode: InfixMode.Value): Tree = { - if (isIdent && in.name != nme.STAR) { - val opOffset = in.offset + // Detect postfix star for repeated args. + // Only RPAREN can follow, but accept COMMA and EQUALS for error's sake. + // Take RBRACE as a paren typo. + def checkRepeatedParam = if (isRawStar) { + lookingAhead (in.token match { + case RPAREN | COMMA | EQUALS | RBRACE => t + case _ => EmptyTree + }) + } else EmptyTree + def asInfix = { + val opOffset = in.offset val leftAssoc = treeInfo.isLeftAssoc(in.name) - if (mode != InfixMode.FirstOp) checkAssoc(opOffset, in.name, leftAssoc = mode == InfixMode.LeftOp) - val op = identForType() - val tycon = atPos(opOffset) { Ident(op) } + if (mode != InfixMode.FirstOp) + checkAssoc(opOffset, in.name, leftAssoc = mode == InfixMode.LeftOp) + val tycon = atPos(opOffset) { Ident(identForType()) } newLineOptWhenFollowing(isTypeIntroToken) def mkOp(t1: Tree) = atPos(t.pos.start, opOffset) { AppliedTypeTree(tycon, List(t, t1)) } if (leftAssoc) infixTypeRest(mkOp(compoundType()), InfixMode.LeftOp) else mkOp(infixType(InfixMode.RightOp)) - } else t + } + if (isIdent) checkRepeatedParam orElse asInfix + else t } /** {{{ diff --git a/test/files/neg/t8325-b.check b/test/files/neg/t8325-b.check new file mode 100644 index 000000000000..ec80826dc084 --- /dev/null +++ b/test/files/neg/t8325-b.check @@ -0,0 +1,10 @@ +t8325-b.scala:3: error: Unmatched closing brace '}' ignored here + def k(is: Int*} = ??? + ^ +t8325-b.scala:3: error: ';' expected but '=' found. + def k(is: Int*} = ??? + ^ +t8325-b.scala:4: error: eof expected but '}' found. +} +^ +three errors found diff --git a/test/files/neg/t8325-b.scala b/test/files/neg/t8325-b.scala new file mode 100644 index 000000000000..6ac78708bbaa --- /dev/null +++ b/test/files/neg/t8325-b.scala @@ -0,0 +1,4 @@ + +trait Test { + def k(is: Int*} = ??? +} diff --git a/test/files/neg/t8325-c.check b/test/files/neg/t8325-c.check new file mode 100644 index 000000000000..51ea4988a649 --- /dev/null +++ b/test/files/neg/t8325-c.check @@ -0,0 +1,7 @@ +t8325-c.scala:3: error: identifier expected but ')' found. + def k(xx: Int`*`) = ??? + ^ +t8325-c.scala:4: error: ')' expected but '}' found. +} +^ +two errors found diff --git a/test/files/neg/t8325-c.scala b/test/files/neg/t8325-c.scala new file mode 100644 index 000000000000..076202df3fa6 --- /dev/null +++ b/test/files/neg/t8325-c.scala @@ -0,0 +1,4 @@ + +trait Test { + def k(xx: Int`*`) = ??? +} diff --git a/test/files/neg/t8325.check b/test/files/neg/t8325.check new file mode 100644 index 000000000000..175a0db41511 --- /dev/null +++ b/test/files/neg/t8325.check @@ -0,0 +1,15 @@ +t8325.scala:5: error: *-parameter must come last + def f(is: Int*, s: String) = ??? + ^ +t8325.scala:7: error: *-parameter must come last + def h(is: Int * String *, s: String) = ??? + ^ +t8325.scala:10: error: type mismatch; + found : Int(5) + required: Int* + def j(is: Int* = 5) = ??? + ^ +t8325.scala:10: error: a parameter section with a `*'-parameter is not allowed to have default arguments + def j(is: Int* = 5) = ??? + ^ +four errors found diff --git a/test/files/neg/t8325.scala b/test/files/neg/t8325.scala new file mode 100644 index 000000000000..3813797e832e --- /dev/null +++ b/test/files/neg/t8325.scala @@ -0,0 +1,11 @@ + +trait Test { + type OK[A,B] = A Tuple2 B + type *[A,B] = A Tuple2 B + def f(is: Int*, s: String) = ??? + def g(is: Int * String, s: String) = ??? // OK + def h(is: Int * String *, s: String) = ??? + // won't recover from following + //def i(is: Int OK) = ??? //error: identifier expected but ')' found. + def j(is: Int* = 5) = ??? +} diff --git a/test/files/pos/t8325.scala b/test/files/pos/t8325.scala new file mode 100644 index 000000000000..af33ee7bb3ba --- /dev/null +++ b/test/files/pos/t8325.scala @@ -0,0 +1,9 @@ + +trait Test { + type +[A, B] = (A, B) + type *[A, B] = (A, B) + + type X[A, B] = A + B + type Y[A, B] = A * B + type Z[A, B] = A `*` B +} From e7ab41e6412c6cf3772ae3153f2a113a8e05699f Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Mon, 5 May 2014 11:39:48 +0200 Subject: [PATCH 212/826] SI-8549 Enforce serialization stability for selected collections To date, we've been hesidant to offer any guarantees about Java serialization of standard library types among heteregenous Scala versions. Nonetheless, we have added `SerialVersionUID` annotations to parts of the standard library, to offer some stability. This protects against two winds of change: automatic calculation of this UID might differ between JVM versions, or it might differ due to otherwise immaterial changes to the library in Scala releases. With this commit, we strengthen the guarantees. Classes marked with `SerialVersionUID` will be serialization compatible within minor releases of Scala. This is backed up by the enclosed test. After major releases, we reserve the right to break this. But the test will serve to avoid *accidental* changes. Specifically, the test case checks: - deserialize(serialize(x)) == x - serialize(x) is stable over time I have included values of all types marked with `@SerialVersionUID` in the library. For some types, I've added variations in the values to exercise different subclasses, such as `Set1` / `Set2`. This found that that the serialized form of predefined `ClassTags` included the cached identity hash code and failed the stability test. This wasn't an issue for correctness as they also provide `readResolve`, but I marked those fields as `@transient` in any case to comply with the test expectations. That whole area is good example of a serialization worst-practice: using anonymous classes in code like: val Object: Manifest[java.lang.Object] = new PhantomManifest[...](...) { private def readResolve(): Any = Manifest.AnyVal } ... will lead to instability if these declarations are shifted around in the file. Named classes would be preferred. I've noted this in a TODO comment for 2.12. --- src/library/scala/reflect/Manifest.scala | 3 + test/files/run/t8549.check | 1 + test/files/run/t8549.scala | 175 +++++++++++++++++++++++ 3 files changed, 179 insertions(+) create mode 100644 test/files/run/t8549.check create mode 100644 test/files/run/t8549.scala diff --git a/src/library/scala/reflect/Manifest.scala b/src/library/scala/reflect/Manifest.scala index 803c980058e6..2f7643bccf6b 100644 --- a/src/library/scala/reflect/Manifest.scala +++ b/src/library/scala/reflect/Manifest.scala @@ -64,6 +64,7 @@ trait Manifest[T] extends ClassManifest[T] with Equals { // TODO undeprecated until Scala reflection becomes non-experimental // @deprecated("Use type tags and manually check the corresponding class or type instead", "2.10.0") +@SerialVersionUID(1L) abstract class AnyValManifest[T <: AnyVal](override val toString: String) extends Manifest[T] with Equals { override def <:<(that: ClassManifest[_]): Boolean = (that eq this) || (that eq Manifest.Any) || (that eq Manifest.AnyVal) @@ -72,6 +73,7 @@ abstract class AnyValManifest[T <: AnyVal](override val toString: String) extend case _ => false } override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef] + @transient override val hashCode = System.identityHashCode(this) } @@ -228,6 +230,7 @@ object ManifestFactory { private abstract class PhantomManifest[T](_runtimeClass: Predef.Class[_], override val toString: String) extends ClassTypeManifest[T](None, _runtimeClass, Nil) { override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef] + @transient override val hashCode = System.identityHashCode(this) } diff --git a/test/files/run/t8549.check b/test/files/run/t8549.check new file mode 100644 index 000000000000..a92ddc0e512a --- /dev/null +++ b/test/files/run/t8549.check @@ -0,0 +1 @@ +warning: there were 2 deprecation warning(s); re-run with -deprecation for details diff --git a/test/files/run/t8549.scala b/test/files/run/t8549.scala new file mode 100644 index 000000000000..1b402d2d22e0 --- /dev/null +++ b/test/files/run/t8549.scala @@ -0,0 +1,175 @@ +import javax.xml.bind.DatatypeConverter._ +import scala.reflect.io.File + +// This test is self-modifying when run as follows: +// +// (export V=v2.10.4 +// scalac-hash $V test/files/run/t8549.scala +// scala-hash $V -Doverwrite.source=test/files/run/t8549.scala Test +// ) +// +// Use this to re-establish a baseline for serialization compatibility. +object Test extends App { + val overwrite: Option[File] = sys.props.get("overwrite.source").map(s => new File(new java.io.File(s))) + + def serialize(o: AnyRef): String = { + val bos = new java.io.ByteArrayOutputStream() + val out = new java.io.ObjectOutputStream(bos) + out.writeObject(o) + out.flush() + printBase64Binary(bos.toByteArray()) + } + + def amend(file: File)(f: String => String) { + file.writeAll(f(file.slurp)) + } + def quote(s: String) = List("\"", s, "\"").mkString + + def patch(file: File, line: Int, prevResult: String, result: String) { + amend(file) { + content => + content.lines.toList.zipWithIndex.map { + case (content, i) if i == line - 1 => + val newContent = content.replaceAllLiterally(quote(prevResult), quote(result)) + if (newContent != content) + println(s"- $content\n+ $newContent\n") + newContent + case (content, _) => content + }.mkString("\n") + } + } + + def updateComment(file: File) { + val timestamp = { + import java.text.SimpleDateFormat + val sdf = new SimpleDateFormat("yyyyMMdd-HH:mm:ss") + sdf.format(new java.util.Date) + } + val newComment = s" // Generated on $timestamp with Scala ${scala.util.Properties.versionString})" + amend(file) { + content => + content.lines.toList.map { + f => f.replaceAll("""^ +// Generated on.*""", newComment) + }.mkString("\n") + } + } + + def deserialize(string: String): AnyRef = { + val bis = new java.io.ByteArrayInputStream(parseBase64Binary(string)) + val in = new java.io.ObjectInputStream(bis) + in.readObject() + } + + def checkRoundTrip[T <: AnyRef](instance: T)(f: T => AnyRef) { + val result = serialize(instance) + val reconstituted = deserialize(result).asInstanceOf[T] + assert(f(instance) == f(reconstituted), (f(instance), f(reconstituted))) + } + + def check[T <: AnyRef](instance: => T)(prevResult: String, f: T => AnyRef = (x: T) => x) { + val result = serialize(instance) + overwrite match { + case Some(f) => + val lineNumberOfLiteralString = Thread.currentThread.getStackTrace.apply(2).getLineNumber + patch(f, lineNumberOfLiteralString, prevResult, result) + case None => + checkRoundTrip(instance)(f) + assert(f(deserialize(prevResult).asInstanceOf[T]) == f(instance), s"$instance != f(deserialize(prevResult))") + assert(prevResult == result, s"instance = $instance : ${instance.getClass}\n serialization unstable: ${prevResult}\n found: ${result}") + } + } + + // Generated on 20140505-14:47:14 with Scala version 2.11.1-20140505-142300-e8562571d2) + overwrite.foreach(updateComment) + + check(List(1, 2, 3))( "rO0ABXNyADJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAABAwAAeHBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJzcQB+AAIAAAADc3IALHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3RTZXJpYWxpemVFbmQkilxjW/dTC20CAAB4cHg=") + check(Nil)( "rO0ABXNyADJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAABAwAAeHBzcgAsc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuTGlzdFNlcmlhbGl6ZUVuZCSKXGNb91MLbQIAAHhweA==") + + check(Vector(1))( "rO0ABXNyACFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5WZWN0b3Lkd3dcHq6PXAIAC0kABWRlcHRoWgAFZGlydHlJAAhlbmRJbmRleEkABWZvY3VzSQAKc3RhcnRJbmRleFsACGRpc3BsYXkwdAATW0xqYXZhL2xhbmcvT2JqZWN0O1sACGRpc3BsYXkxcQB+AAFbAAhkaXNwbGF5MnEAfgABWwAIZGlzcGxheTNxAH4AAVsACGRpc3BsYXk0cQB+AAFbAAhkaXNwbGF5NXEAfgABeHAAAAABAAAAAAEAAAAAAAAAAHVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAACBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcA==") + check(Vector())( "rO0ABXNyACFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5WZWN0b3Lkd3dcHq6PXAIAC0kABWRlcHRoWgAFZGlydHlJAAhlbmRJbmRleEkABWZvY3VzSQAKc3RhcnRJbmRleFsACGRpc3BsYXkwdAATW0xqYXZhL2xhbmcvT2JqZWN0O1sACGRpc3BsYXkxcQB+AAFbAAhkaXNwbGF5MnEAfgABWwAIZGlzcGxheTNxAH4AAVsACGRpc3BsYXk0cQB+AAFbAAhkaXNwbGF5NXEAfgABeHAAAAAAAAAAAAAAAAAAAAAAAHBwcHBwcA==") + + object Enum extends Enumeration { + val V1 = new Value { def id = 42 } + val V2 = new Val(42) + } + + import collection.{ mutable, immutable } + + class C + check(reflect.classTag[C])("rO0ABXNyAB5zY2FsYS5yZWZsZWN0LkNsYXNzVGFnJCRhbm9uJDG7ePPrmQBkhgIAAUwAD3J1bnRpbWVDbGFzczEkMXQAEUxqYXZhL2xhbmcvQ2xhc3M7eHB2cgAGVGVzdCRDAAAAAAAAAAAAAAB4cA==") + check(reflect.classTag[Int])("rO0ABXNyACVzY2FsYS5yZWZsZWN0Lk1hbmlmZXN0RmFjdG9yeSQkYW5vbiQ5zfmiSVNjtVICAAB4cgAcc2NhbGEucmVmbGVjdC5BbnlWYWxNYW5pZmVzdAAAAAAAAAABAgABTAAIdG9TdHJpbmd0ABJMamF2YS9sYW5nL1N0cmluZzt4cHQAA0ludA==") + check(reflect.classTag[String])("rO0ABXNyAB5zY2FsYS5yZWZsZWN0LkNsYXNzVGFnJCRhbm9uJDG7ePPrmQBkhgIAAUwAD3J1bnRpbWVDbGFzczEkMXQAEUxqYXZhL2xhbmcvQ2xhc3M7eHB2cgAQamF2YS5sYW5nLlN0cmluZ6DwpDh6O7NCAgAAeHA=") + check(reflect.classTag[Object])("rO0ABXNyACVzY2FsYS5yZWZsZWN0Lk1hbmlmZXN0RmFjdG9yeSQkYW5vbiQymPrtq/Ci1gsCAAB4cgAtc2NhbGEucmVmbGVjdC5NYW5pZmVzdEZhY3RvcnkkUGhhbnRvbU1hbmlmZXN0rzigP7KRh/kCAAFMAAh0b1N0cmluZ3QAEkxqYXZhL2xhbmcvU3RyaW5nO3hyAC9zY2FsYS5yZWZsZWN0Lk1hbmlmZXN0RmFjdG9yeSRDbGFzc1R5cGVNYW5pZmVzdFq6NWvfTgYFAgADTAAGcHJlZml4dAAOTHNjYWxhL09wdGlvbjtMAAxydW50aW1lQ2xhc3N0ABFMamF2YS9sYW5nL0NsYXNzO0wADXR5cGVBcmd1bWVudHN0ACFMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvTGlzdDt4cHNyAAtzY2FsYS5Ob25lJEZQJPZTypSsAgAAeHIADHNjYWxhLk9wdGlvbv5pN/3bDmZ0AgAAeHB2cgAQamF2YS5sYW5nLk9iamVjdAAAAAAAAAAAAAAAeHBzcgAyc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuTGlzdCRTZXJpYWxpemF0aW9uUHJveHkAAAAAAAAAAQMAAHhwc3IALHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3RTZXJpYWxpemVFbmQkilxjW/dTC20CAAB4cHh0AAZPYmplY3Q=") + + check(Enum)( "rO0ABXNyAApUZXN0JEVudW0ketCIyQ8C23MCAAJMAAJWMXQAGUxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZTtMAAJWMnQAF0xzY2FsYS9FbnVtZXJhdGlvbiRWYWw7eHIAEXNjYWxhLkVudW1lcmF0aW9udaDN3ZgOWY4CAAhJAAZuZXh0SWRJABtzY2FsYSRFbnVtZXJhdGlvbiQkYm90dG9tSWRJABhzY2FsYSRFbnVtZXJhdGlvbiQkdG9wSWRMABRWYWx1ZU9yZGVyaW5nJG1vZHVsZXQAIkxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZU9yZGVyaW5nJDtMAA9WYWx1ZVNldCRtb2R1bGV0AB1Mc2NhbGEvRW51bWVyYXRpb24kVmFsdWVTZXQkO0wACG5leHROYW1ldAAbTHNjYWxhL2NvbGxlY3Rpb24vSXRlcmF0b3I7TAAXc2NhbGEkRW51bWVyYXRpb24kJG5tYXB0AB5Mc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL01hcDtMABdzY2FsYSRFbnVtZXJhdGlvbiQkdm1hcHEAfgAHeHAAAAArAAAAAAAAACtwcHBzcgAgc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLkhhc2hNYXAAAAAAAAAAAQMAAHhwdw0AAALuAAAAAAAAAAQAeHNxAH4ACXcNAAAC7gAAAAEAAAAEAHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAAqc3IAFXNjYWxhLkVudW1lcmF0aW9uJFZhbM9pZ6/J/O1PAgACSQAYc2NhbGEkRW51bWVyYXRpb24kVmFsJCRpTAAEbmFtZXQAEkxqYXZhL2xhbmcvU3RyaW5nO3hyABdzY2FsYS5FbnVtZXJhdGlvbiRWYWx1ZWJpfC/tIR1RAgACTAAGJG91dGVydAATTHNjYWxhL0VudW1lcmF0aW9uO0wAHHNjYWxhJEVudW1lcmF0aW9uJCRvdXRlckVudW1xAH4AEnhwcQB+AAhxAH4ACAAAACpweHNyABFUZXN0JEVudW0kJGFub24kMVlIjlmE1sXaAgAAeHEAfgARcQB+AAhxAH4ACHEAfgAT") + check(Enum.V1)( "rO0ABXNyABFUZXN0JEVudW0kJGFub24kMVlIjlmE1sXaAgAAeHIAF3NjYWxhLkVudW1lcmF0aW9uJFZhbHVlYml8L+0hHVECAAJMAAYkb3V0ZXJ0ABNMc2NhbGEvRW51bWVyYXRpb247TAAcc2NhbGEkRW51bWVyYXRpb24kJG91dGVyRW51bXEAfgACeHBzcgAKVGVzdCRFbnVtJHrQiMkPAttzAgACTAACVjF0ABlMc2NhbGEvRW51bWVyYXRpb24kVmFsdWU7TAACVjJ0ABdMc2NhbGEvRW51bWVyYXRpb24kVmFsO3hyABFzY2FsYS5FbnVtZXJhdGlvbnWgzd2YDlmOAgAISQAGbmV4dElkSQAbc2NhbGEkRW51bWVyYXRpb24kJGJvdHRvbUlkSQAYc2NhbGEkRW51bWVyYXRpb24kJHRvcElkTAAUVmFsdWVPcmRlcmluZyRtb2R1bGV0ACJMc2NhbGEvRW51bWVyYXRpb24kVmFsdWVPcmRlcmluZyQ7TAAPVmFsdWVTZXQkbW9kdWxldAAdTHNjYWxhL0VudW1lcmF0aW9uJFZhbHVlU2V0JDtMAAhuZXh0TmFtZXQAG0xzY2FsYS9jb2xsZWN0aW9uL0l0ZXJhdG9yO0wAF3NjYWxhJEVudW1lcmF0aW9uJCRubWFwdAAeTHNjYWxhL2NvbGxlY3Rpb24vbXV0YWJsZS9NYXA7TAAXc2NhbGEkRW51bWVyYXRpb24kJHZtYXBxAH4AC3hwAAAAKwAAAAAAAAArcHBwc3IAIHNjYWxhLmNvbGxlY3Rpb24ubXV0YWJsZS5IYXNoTWFwAAAAAAAAAAEDAAB4cHcNAAAC7gAAAAAAAAAEAHhzcQB+AA13DQAAAu4AAAABAAAABABzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAKnNyABVzY2FsYS5FbnVtZXJhdGlvbiRWYWzPaWevyfztTwIAAkkAGHNjYWxhJEVudW1lcmF0aW9uJFZhbCQkaUwABG5hbWV0ABJMamF2YS9sYW5nL1N0cmluZzt4cQB+AAFxAH4ADHEAfgAMAAAAKnB4cQB+AANxAH4AFXEAfgAM") + check(Enum.V2)( "rO0ABXNyABVzY2FsYS5FbnVtZXJhdGlvbiRWYWzPaWevyfztTwIAAkkAGHNjYWxhJEVudW1lcmF0aW9uJFZhbCQkaUwABG5hbWV0ABJMamF2YS9sYW5nL1N0cmluZzt4cgAXc2NhbGEuRW51bWVyYXRpb24kVmFsdWViaXwv7SEdUQIAAkwABiRvdXRlcnQAE0xzY2FsYS9FbnVtZXJhdGlvbjtMABxzY2FsYSRFbnVtZXJhdGlvbiQkb3V0ZXJFbnVtcQB+AAN4cHNyAApUZXN0JEVudW0ketCIyQ8C23MCAAJMAAJWMXQAGUxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZTtMAAJWMnQAF0xzY2FsYS9FbnVtZXJhdGlvbiRWYWw7eHIAEXNjYWxhLkVudW1lcmF0aW9udaDN3ZgOWY4CAAhJAAZuZXh0SWRJABtzY2FsYSRFbnVtZXJhdGlvbiQkYm90dG9tSWRJABhzY2FsYSRFbnVtZXJhdGlvbiQkdG9wSWRMABRWYWx1ZU9yZGVyaW5nJG1vZHVsZXQAIkxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZU9yZGVyaW5nJDtMAA9WYWx1ZVNldCRtb2R1bGV0AB1Mc2NhbGEvRW51bWVyYXRpb24kVmFsdWVTZXQkO0wACG5leHROYW1ldAAbTHNjYWxhL2NvbGxlY3Rpb24vSXRlcmF0b3I7TAAXc2NhbGEkRW51bWVyYXRpb24kJG5tYXB0AB5Mc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL01hcDtMABdzY2FsYSRFbnVtZXJhdGlvbiQkdm1hcHEAfgAMeHAAAAArAAAAAAAAACtwcHBzcgAgc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLkhhc2hNYXAAAAAAAAAAAQMAAHhwdw0AAALuAAAAAAAAAAQAeHNxAH4ADncNAAAC7gAAAAEAAAAEAHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAAqcQB+AAR4c3IAEVRlc3QkRW51bSQkYW5vbiQxWUiOWYTWxdoCAAB4cQB+AAJxAH4ADXEAfgANcQB+AARxAH4ADQAAACpw") + + // IndexedSeqLike#Elements + check(new immutable.Range(0, 1, 1).iterator)("rO0ABXNyAChzY2FsYS5jb2xsZWN0aW9uLkluZGV4ZWRTZXFMaWtlJEVsZW1lbnRzGF+1cBwmcx0CAANJAANlbmRJAAVpbmRleEwABiRvdXRlcnQAIUxzY2FsYS9jb2xsZWN0aW9uL0luZGV4ZWRTZXFMaWtlO3hwAAAAAQAAAABzcgAgc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuUmFuZ2Vpu6NUqxUyDQIAB0kAA2VuZFoAB2lzRW1wdHlJAAtsYXN0RWxlbWVudEkAEG51bVJhbmdlRWxlbWVudHNJAAVzdGFydEkABHN0ZXBJAA90ZXJtaW5hbEVsZW1lbnR4cAAAAAEAAAAAAAAAAAEAAAAAAAAAAQAAAAE=" + , _.toList) + + check(new collection.concurrent.TrieMap[Any, Any]())( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLmNvbmN1cnJlbnQuVHJpZU1hcKckxpgOIYHPAwAETAALZXF1YWxpdHlvYmp0ABJMc2NhbGEvbWF0aC9FcXVpdjtMAApoYXNoaW5nb2JqdAAcTHNjYWxhL3V0aWwvaGFzaGluZy9IYXNoaW5nO0wABHJvb3R0ABJMamF2YS9sYW5nL09iamVjdDtMAAtyb290dXBkYXRlcnQAOUxqYXZhL3V0aWwvY29uY3VycmVudC9hdG9taWMvQXRvbWljUmVmZXJlbmNlRmllbGRVcGRhdGVyO3hwc3IAMnNjYWxhLmNvbGxlY3Rpb24uY29uY3VycmVudC5UcmllTWFwJE1hbmdsZWRIYXNoaW5nhTBoJQ/mgb0CAAB4cHNyABhzY2FsYS5tYXRoLkVxdWl2JCRhbm9uJDLBbyx4dy/qGwIAAHhwc3IANHNjYWxhLmNvbGxlY3Rpb24uY29uY3VycmVudC5UcmllTWFwU2VyaWFsaXphdGlvbkVuZCSbjdgbbGCt2gIAAHhweA==") + // not sure why this one needs stable serialization. + check(collection.convert.Wrappers)( "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") + + check(immutable.BitSet(1, 2, 3))( "rO0ABXNyAClzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5CaXRTZXQkQml0U2V0MR9dg8JGRI8UAgABSgAFZWxlbXN4cgAhc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuQml0U2V0Flz5Ms3qxsoCAAB4cAAAAAAAAAAO") + check(immutable.HashMap())( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoTWFwJFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAAB4") + check(immutable.HashMap(1 -> 2))( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoTWFwJFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAAFzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJ4") + check(immutable.HashMap(1 -> 2, 3 -> 4))( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoTWFwJFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAAJzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJzcQB+AAIAAAADc3EAfgACAAAABHg=") + // TODO provoke HashMapCollision1 + + check(immutable.HashSet())( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoU2V0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAAB4") + check(immutable.HashSet(1))( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoU2V0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAAFzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXg=") + check(immutable.HashSet(1, 2))( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoU2V0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAAJzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJ4") + check(immutable.HashSet(1, 2, 3))( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoU2V0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAANzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJzcQB+AAIAAAADeA==") + // TODO provoke HashSetCollision1 + + check(immutable.ListMap())( "rO0ABXNyADBzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0TWFwJEVtcHR5TGlzdE1hcCSNalsvpBZeDgIAAHhyACJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0TWFwBC1gfIkUSKsCAAB4cA==") + check(immutable.ListMap(1 -> 2))( "rO0ABXNyACdzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0TWFwJE5vZGWmciM1Yav+8gIAA0wABiRvdXRlcnQAJExzY2FsYS9jb2xsZWN0aW9uL2ltbXV0YWJsZS9MaXN0TWFwO0wAA2tleXQAEkxqYXZhL2xhbmcvT2JqZWN0O0wABXZhbHVlcQB+AAJ4cgAic2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuTGlzdE1hcAQtYHyJFEirAgAAeHBzcgAwc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuTGlzdE1hcCRFbXB0eUxpc3RNYXAkjWpbL6QWXg4CAAB4cQB+AANzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABwAAAAI=") + check(immutable.Queue())( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5RdWV1ZZY146W3qSuhAgACTAACaW50ACFMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvTGlzdDtMAANvdXRxAH4AAXhwc3IAMnNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3QkU2VyaWFsaXphdGlvblByb3h5AAAAAAAAAAEDAAB4cHNyACxzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0U2VyaWFsaXplRW5kJIpcY1v3UwttAgAAeHB4cQB+AAQ=") + check(immutable.Queue(1, 2, 3))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5RdWV1ZZY146W3qSuhAgACTAACaW50ACFMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvTGlzdDtMAANvdXRxAH4AAXhwc3IAMnNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3QkU2VyaWFsaXphdGlvblByb3h5AAAAAAAAAAEDAAB4cHNyACxzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0U2VyaWFsaXplRW5kJIpcY1v3UwttAgAAeHB4c3EAfgADc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcQB+AAgAAAACc3EAfgAIAAAAA3EAfgAGeA==") + + check(new immutable.Range(0, 1, 1))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5SYW5nZWm7o1SrFTINAgAHSQADZW5kWgAHaXNFbXB0eUkAC2xhc3RFbGVtZW50SQAQbnVtUmFuZ2VFbGVtZW50c0kABXN0YXJ0SQAEc3RlcEkAD3Rlcm1pbmFsRWxlbWVudHhwAAAAAQAAAAAAAAAAAQAAAAAAAAABAAAAAQ==") + + check(immutable.Set())( "rO0ABXNyAChzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TZXQkRW1wdHlTZXQk8Hk3TFN0uDYCAAB4cA==") + check(immutable.Set(1))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TZXQkU2V0MREd3c4yqtWTAgABTAAFZWxlbTF0ABJMamF2YS9sYW5nL09iamVjdDt4cHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAAB") + check(immutable.Set(1, 2))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TZXQkU2V0MqaV02sZQzV0AgACTAAFZWxlbTF0ABJMamF2YS9sYW5nL09iamVjdDtMAAVlbGVtMnEAfgABeHBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAwAAAAI=") + check(immutable.Set(1, 2, 3))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TZXQkU2V0M84syT0560SgAgADTAAFZWxlbTF0ABJMamF2YS9sYW5nL09iamVjdDtMAAVlbGVtMnEAfgABTAAFZWxlbTNxAH4AAXhwc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcQB+AAMAAAACc3EAfgADAAAAAw==") + check(immutable.Set(1, 2, 3, 4))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TZXQkU2V0NM26psRRbei1AgAETAAFZWxlbTF0ABJMamF2YS9sYW5nL09iamVjdDtMAAVlbGVtMnEAfgABTAAFZWxlbTNxAH4AAUwABWVsZW00cQB+AAF4cHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAABc3EAfgADAAAAAnNxAH4AAwAAAANzcQB+AAMAAAAE") + check(immutable.Set(1, 2, 3, 4, 5))( "rO0ABXNyADVzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5IYXNoU2V0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAACAwAAeHB3BAAAAAVzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAABXNxAH4AAgAAAAFzcQB+AAIAAAACc3EAfgACAAAAA3NxAH4AAgAAAAR4") + + check(immutable.Stack(1, 2, 3))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TdGFjaxtt3qEbMvq+AgABTAAFZWxlbXN0ACFMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvTGlzdDt4cHNyADJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAABAwAAeHBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABQAAAAJzcQB+AAUAAAADc3IALHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3RTZXJpYWxpemVFbmQkilxjW/dTC20CAAB4cHg=") + + check(immutable.Stream(1, 2, 3))( "rO0ABXNyACZzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TdHJlYW0kQ29uc/ekjBXM3TlFAgADTAACaGR0ABJMamF2YS9sYW5nL09iamVjdDtMAAV0bEdlbnQAEUxzY2FsYS9GdW5jdGlvbjA7TAAFdGxWYWx0ACNMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvU3RyZWFtO3hyACFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TdHJlYW0552RDntM42gIAAHhwc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcgAtc2NhbGEuY29sbGVjdGlvbi5JdGVyYXRvciQkYW5vbmZ1biR0b1N0cmVhbSQxRWR4We0SX0UCAAFMAAYkb3V0ZXJ0ABtMc2NhbGEvY29sbGVjdGlvbi9JdGVyYXRvcjt4cHNyAChzY2FsYS5jb2xsZWN0aW9uLkluZGV4ZWRTZXFMaWtlJEVsZW1lbnRzGF+1cBwmcx0CAANJAANlbmRJAAVpbmRleEwABiRvdXRlcnQAIUxzY2FsYS9jb2xsZWN0aW9uL0luZGV4ZWRTZXFMaWtlO3hwAAAAAwAAAAFzcgArc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLldyYXBwZWRBcnJheSRvZkludMmRLBcI15VjAgABWwAFYXJyYXl0AAJbSXhwdXIAAltJTbpgJnbqsqUCAAB4cAAAAAMAAAABAAAAAgAAAANw") + + check(immutable.TreeSet[Int]())( "rO0ABXNyACJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5UcmVlU2V0sRdVIDjbWAsCAAJMAAhvcmRlcmluZ3QAFUxzY2FsYS9tYXRoL09yZGVyaW5nO0wABHRyZWV0AC5Mc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvUmVkQmxhY2tUcmVlJFRyZWU7eHBzcgAYc2NhbGEubWF0aC5PcmRlcmluZyRJbnQkC4BMdr1Z51wCAAB4cHA=") + check(immutable.TreeSet(1, 2, 3))( "rO0ABXNyACJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5UcmVlU2V0sRdVIDjbWAsCAAJMAAhvcmRlcmluZ3QAFUxzY2FsYS9tYXRoL09yZGVyaW5nO0wABHRyZWV0AC5Mc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvUmVkQmxhY2tUcmVlJFRyZWU7eHBzcgAYc2NhbGEubWF0aC5PcmRlcmluZyRJbnQkC4BMdr1Z51wCAAB4cHNyADFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5SZWRCbGFja1RyZWUkQmxhY2tUcmVlzRxnCKenVAECAAB4cgAsc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuUmVkQmxhY2tUcmVlJFRyZWVrqCSyHJbsMgIABUkABWNvdW50TAADa2V5dAASTGphdmEvbGFuZy9PYmplY3Q7TAAEbGVmdHEAfgACTAAFcmlnaHRxAH4AAkwABXZhbHVlcQB+AAh4cAAAAANzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAnNxAH4ABgAAAAFzcQB+AAoAAAABcHBzcgAXc2NhbGEucnVudGltZS5Cb3hlZFVuaXR0pn1HHezLmgIAAHhwc3EAfgAGAAAAAXNxAH4ACgAAAANwcHEAfgAQcQB+ABA=") + + check(mutable.ArrayBuffer(1, 2, 3))( "rO0ABXNyACRzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuQXJyYXlCdWZmZXIVOLBTg4KOcwIAA0kAC2luaXRpYWxTaXplSQAFc2l6ZTBbAAVhcnJheXQAE1tMamF2YS9sYW5nL09iamVjdDt4cAAAABAAAAADdXIAE1tMamF2YS5sYW5nLk9iamVjdDuQzlifEHMpbAIAAHhwAAAAEHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAABc3EAfgAFAAAAAnNxAH4ABQAAAANwcHBwcHBwcHBwcHBw") + check(mutable.ArraySeq(1, 2, 3))( "rO0ABXNyACFzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuQXJyYXlTZXEVPD3SKEkOcwIAAkkABmxlbmd0aFsABWFycmF5dAATW0xqYXZhL2xhbmcvT2JqZWN0O3hwAAAAA3VyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAANzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABQAAAAJzcQB+AAUAAAAD") + check(mutable.ArrayStack(1, 2, 3))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuQXJyYXlTdGFja3bdxXbcnLBeAgACSQAqc2NhbGEkY29sbGVjdGlvbiRtdXRhYmxlJEFycmF5U3RhY2skJGluZGV4WwAqc2NhbGEkY29sbGVjdGlvbiRtdXRhYmxlJEFycmF5U3RhY2skJHRhYmxldAATW0xqYXZhL2xhbmcvT2JqZWN0O3hwAAAAA3VyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAANzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAA3NxAH4ABQAAAAJzcQB+AAUAAAAB") + check(mutable.DoubleLinkedList(1, 2, 3))( "rO0ABXNyAClzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuRG91YmxlTGlua2VkTGlzdI73LKsKRr1RAgADTAAEZWxlbXQAEkxqYXZhL2xhbmcvT2JqZWN0O0wABG5leHR0AB5Mc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL1NlcTtMAARwcmV2cQB+AAJ4cHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAABc3EAfgAAc3EAfgAEAAAAAnNxAH4AAHNxAH4ABAAAAANzcQB+AABwcQB+AAtxAH4ACXEAfgAHcQB+AANw") + + check(mutable.HashMap())( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuSGFzaE1hcAAAAAAAAAABAwAAeHB3DQAAAu4AAAAAAAAABAB4") + check(mutable.HashMap(1 -> 1))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuSGFzaE1hcAAAAAAAAAABAwAAeHB3DQAAAu4AAAABAAAABABzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXEAfgAEeA==") + check(mutable.HashSet(1, 2, 3))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuSGFzaFNldAAAAAAAAAABAwAAeHB3DQAAAcIAAAADAAAABQBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJzcQB+AAIAAAADeA==") + check(new mutable.History())( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuSGlzdG9yeUhuXxDIFJrsAgACSQAKbWF4SGlzdG9yeUwAA2xvZ3QAIExzY2FsYS9jb2xsZWN0aW9uL211dGFibGUvUXVldWU7eHAAAAPoc3IAHnNjYWxhLmNvbGxlY3Rpb24ubXV0YWJsZS5RdWV1ZbjMURVfOuHHAgAAeHIAJHNjYWxhLmNvbGxlY3Rpb24ubXV0YWJsZS5NdXRhYmxlTGlzdFJpnjJ+gFbAAgADSQADbGVuTAAGZmlyc3QwdAAlTHNjYWxhL2NvbGxlY3Rpb24vbXV0YWJsZS9MaW5rZWRMaXN0O0wABWxhc3QwcQB+AAV4cAAAAABzcgAjc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLkxpbmtlZExpc3Sak+nGCZHaUQIAAkwABGVsZW10ABJMamF2YS9sYW5nL09iamVjdDtMAARuZXh0dAAeTHNjYWxhL2NvbGxlY3Rpb24vbXV0YWJsZS9TZXE7eHBwcQB+AApxAH4ACg==") + check(mutable.LinkedHashMap(1 -> 2))( "rO0ABXNyACZzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuTGlua2VkSGFzaE1hcAAAAAAAAAABAwAAeHB3DQAAAu4AAAABAAAABABzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJ4") + check(mutable.LinkedHashSet(1, 2, 3))( "rO0ABXNyACZzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuTGlua2VkSGFzaFNldAAAAAAAAAABAwAAeHB3DQAAAu4AAAADAAAABABzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJzcQB+AAIAAAADeA==") + check(mutable.LinkedList(1, 2, 3))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuTGlua2VkTGlzdJqT6cYJkdpRAgACTAAEZWxlbXQAEkxqYXZhL2xhbmcvT2JqZWN0O0wABG5leHR0AB5Mc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL1NlcTt4cHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAABc3EAfgAAc3EAfgAEAAAAAnNxAH4AAHNxAH4ABAAAAANzcQB+AABwcQB+AAs=") + check(mutable.ListBuffer(1, 2, 3))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuTGlzdEJ1ZmZlci9y9I7QyWzGAwAEWgAIZXhwb3J0ZWRJAANsZW5MAAVsYXN0MHQAKUxzY2FsYS9jb2xsZWN0aW9uL2ltbXV0YWJsZS8kY29sb24kY29sb247TAAqc2NhbGEkY29sbGVjdGlvbiRtdXRhYmxlJExpc3RCdWZmZXIkJHN0YXJ0dAAhTHNjYWxhL2NvbGxlY3Rpb24vaW1tdXRhYmxlL0xpc3Q7eHBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABAAAAAJzcQB+AAQAAAADc3IALHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3RTZXJpYWxpemVFbmQkilxjW/dTC20CAAB4cHcFAAAAAAN4") + check(new mutable.StringBuilder(new java.lang.StringBuilder("123")))( "rO0ABXNyACZzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuU3RyaW5nQnVpbGRlcomvqgGv1tTxAgABTAAKdW5kZXJseWluZ3QAGUxqYXZhL2xhbmcvU3RyaW5nQnVpbGRlcjt4cHNyABdqYXZhLmxhbmcuU3RyaW5nQnVpbGRlcjzV+xRaTGrLAwAAeHB3BAAAAAN1cgACW0OwJmaw4l2ErAIAAHhwAAAAEwAxADIAMwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeA==") + check(mutable.UnrolledBuffer[Int]())( "rO0ABXNyACdzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuVW5yb2xsZWRCdWZmZXIAAAAAAAAAAQMAAUwAA3RhZ3QAGExzY2FsYS9yZWZsZWN0L0NsYXNzVGFnO3hwc3IAJXNjYWxhLnJlZmxlY3QuTWFuaWZlc3RGYWN0b3J5JCRhbm9uJDnN+aJJU2O1UgIAAHhyABxzY2FsYS5yZWZsZWN0LkFueVZhbE1hbmlmZXN0AAAAAAAAAAECAAFMAAh0b1N0cmluZ3QAEkxqYXZhL2xhbmcvU3RyaW5nO3hwdAADSW50dwQAAAAAeA==") + + import collection.parallel + check(parallel.immutable.ParHashMap(1 -> 2))( "rO0ABXNyAC5zY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLmltbXV0YWJsZS5QYXJIYXNoTWFwAAAAAAAAAAECAANMAA9TY2FuTGVhZiRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2NhbkxlYWYkO0wAD1NjYW5Ob2RlJG1vZHVsZXQANUxzY2FsYS9jb2xsZWN0aW9uL3BhcmFsbGVsL1Bhckl0ZXJhYmxlTGlrZSRTY2FuTm9kZSQ7TAAEdHJpZXQAJExzY2FsYS9jb2xsZWN0aW9uL2ltbXV0YWJsZS9IYXNoTWFwO3hwcHBzcgA1c2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuSGFzaE1hcCRTZXJpYWxpemF0aW9uUHJveHkAAAAAAAAAAgMAAHhwdwQAAAABc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcQB+AAcAAAACeA==") + check(parallel.immutable.ParHashSet(1, 2, 3))( "rO0ABXNyAC5zY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLmltbXV0YWJsZS5QYXJIYXNoU2V0AAAAAAAAAAECAANMAA9TY2FuTGVhZiRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2NhbkxlYWYkO0wAD1NjYW5Ob2RlJG1vZHVsZXQANUxzY2FsYS9jb2xsZWN0aW9uL3BhcmFsbGVsL1Bhckl0ZXJhYmxlTGlrZSRTY2FuTm9kZSQ7TAAEdHJpZXQAJExzY2FsYS9jb2xsZWN0aW9uL2ltbXV0YWJsZS9IYXNoU2V0O3hwcHBzcgA1c2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuSGFzaFNldCRTZXJpYWxpemF0aW9uUHJveHkAAAAAAAAAAgMAAHhwdwQAAAADc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcQB+AAcAAAACc3EAfgAHAAAAA3g=") + check(new parallel.immutable.ParRange(new Range(0, 1, 2)))( "rO0ABXNyACxzY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLmltbXV0YWJsZS5QYXJSYW5nZQAAAAAAAAABAgAETAAXUGFyUmFuZ2VJdGVyYXRvciRtb2R1bGV0AEBMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9pbW11dGFibGUvUGFyUmFuZ2UkUGFyUmFuZ2VJdGVyYXRvciQ7TAAPU2NhbkxlYWYkbW9kdWxldAA1THNjYWxhL2NvbGxlY3Rpb24vcGFyYWxsZWwvUGFySXRlcmFibGVMaWtlJFNjYW5MZWFmJDtMAA9TY2FuTm9kZSRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2Nhbk5vZGUkO0wABXJhbmdldAAiTHNjYWxhL2NvbGxlY3Rpb24vaW1tdXRhYmxlL1JhbmdlO3hwcHBwc3IAIHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLlJhbmdlabujVKsVMg0CAAdJAANlbmRaAAdpc0VtcHR5SQALbGFzdEVsZW1lbnRJABBudW1SYW5nZUVsZW1lbnRzSQAFc3RhcnRJAARzdGVwSQAPdGVybWluYWxFbGVtZW50eHAAAAABAAAAAAAAAAABAAAAAAAAAAIAAAAC") + check(parallel.mutable.ParArray(1, 2, 3))( "rO0ABXNyACpzY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLm11dGFibGUuUGFyQXJyYXkAAAAAAAAAAQMABEwAF1BhckFycmF5SXRlcmF0b3IkbW9kdWxldAA+THNjYWxhL2NvbGxlY3Rpb24vcGFyYWxsZWwvbXV0YWJsZS9QYXJBcnJheSRQYXJBcnJheUl0ZXJhdG9yJDtMAA9TY2FuTGVhZiRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2NhbkxlYWYkO0wAD1NjYW5Ob2RlJG1vZHVsZXQANUxzY2FsYS9jb2xsZWN0aW9uL3BhcmFsbGVsL1Bhckl0ZXJhYmxlTGlrZSRTY2FuTm9kZSQ7TAAIYXJyYXlzZXF0ACNMc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL0FycmF5U2VxO3hwcHBwc3IAMXNjYWxhLmNvbGxlY3Rpb24ucGFyYWxsZWwubXV0YWJsZS5FeHBvc2VkQXJyYXlTZXGx2OTefAodSQIAAkkABmxlbmd0aFsABWFycmF5dAATW0xqYXZhL2xhbmcvT2JqZWN0O3hyACFzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuQXJyYXlTZXEVPD3SKEkOcwIAAkkABmxlbmd0aFsABWFycmF5cQB+AAd4cAAAAAN1cgATW0xqYXZhLmxhbmcuT2JqZWN0O5DOWJ8QcylsAgAAeHAAAAADcHBwAAAAA3VxAH4ACgAAABBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ADQAAAAJzcQB+AA0AAAADcHBwcHBwcHBwcHBwcHg=") + check(parallel.mutable.ParHashMap(1 -> 2))( "rO0ABXNyACxzY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLm11dGFibGUuUGFySGFzaE1hcAAAAAAAAAABAwACTAAPU2NhbkxlYWYkbW9kdWxldAA1THNjYWxhL2NvbGxlY3Rpb24vcGFyYWxsZWwvUGFySXRlcmFibGVMaWtlJFNjYW5MZWFmJDtMAA9TY2FuTm9kZSRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2Nhbk5vZGUkO3hwcHB3DQAAAu4AAAABAAAABAFzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABAAAAAJ4") + check(parallel.mutable.ParHashSet(1, 2, 3))( "rO0ABXNyACxzY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLm11dGFibGUuUGFySGFzaFNldAAAAAAAAAABAwACTAAPU2NhbkxlYWYkbW9kdWxldAA1THNjYWxhL2NvbGxlY3Rpb24vcGFyYWxsZWwvUGFySXRlcmFibGVMaWtlJFNjYW5MZWFmJDtMAA9TY2FuTm9kZSRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2Nhbk5vZGUkO3hwcHB3DQAAAcIAAAADAAAAGwFzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABAAAAAJzcQB+AAQAAAADeA==") + + check("...".r)("rO0ABXNyABlzY2FsYS51dGlsLm1hdGNoaW5nLlJlZ2V44u3Vap7wIb8CAAJMAAdwYXR0ZXJudAAZTGphdmEvdXRpbC9yZWdleC9QYXR0ZXJuO0wAJXNjYWxhJHV0aWwkbWF0Y2hpbmckUmVnZXgkJGdyb3VwTmFtZXN0ABZMc2NhbGEvY29sbGVjdGlvbi9TZXE7eHBzcgAXamF2YS51dGlsLnJlZ2V4LlBhdHRlcm5GZ9VrbkkCDQIAAkkABWZsYWdzTAAHcGF0dGVybnQAEkxqYXZhL2xhbmcvU3RyaW5nO3hwAAAAAHQAAy4uLnNyADJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAABAwAAeHBzcgAsc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuTGlzdFNlcmlhbGl6ZUVuZCSKXGNb91MLbQIAAHhweA==", + r => (r.toString)) +} From 2dbd269c7d7a12c2486f66d6f1d57a96ed662f3c Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Mon, 5 May 2014 12:39:14 +0200 Subject: [PATCH 213/826] SI-6988 Test case for non-literal / non-constant SerialVersionUID The `neg` test was already working since `SerialVersionUID` was changed to a `ClassFileAnnotation`; the `run` test only started working since the recently preceding commit that made a compensatory test in the backend. --- test/files/neg/t6988.check | 7 +++++++ test/files/neg/t6988.scala | 10 ++++++++++ test/files/run/t6988.check | 2 ++ test/files/run/t6988.scala | 9 +++++++++ 4 files changed, 28 insertions(+) create mode 100644 test/files/neg/t6988.check create mode 100644 test/files/neg/t6988.scala create mode 100644 test/files/run/t6988.check create mode 100644 test/files/run/t6988.scala diff --git a/test/files/neg/t6988.check b/test/files/neg/t6988.check new file mode 100644 index 000000000000..acb7b3cb082d --- /dev/null +++ b/test/files/neg/t6988.check @@ -0,0 +1,7 @@ +t6988.scala:3: error: annotation argument needs to be a constant; found: 13.asInstanceOf[Long] +@SerialVersionUID(13.asInstanceOf[Long]) case class IdentifyMessage1(userName: String, user: User, code: Int) + ^ +t6988.scala:8: error: annotation argument needs to be a constant; found: O.SerialUID +@SerialVersionUID(O.SerialUID) case class IdentifyMessage3(userName: String, user: User, code: Int) + ^ +two errors found diff --git a/test/files/neg/t6988.scala b/test/files/neg/t6988.scala new file mode 100644 index 000000000000..8171dc9dd0f9 --- /dev/null +++ b/test/files/neg/t6988.scala @@ -0,0 +1,10 @@ +case class User() + +@SerialVersionUID(13.asInstanceOf[Long]) case class IdentifyMessage1(userName: String, user: User, code: Int) +@SerialVersionUID(13l) case class IdentifyMessage2(userName: String, user: User, code: Int) +object O { + val SerialUID = "13".toLong +} +@SerialVersionUID(O.SerialUID) case class IdentifyMessage3(userName: String, user: User, code: Int) + + diff --git a/test/files/run/t6988.check b/test/files/run/t6988.check new file mode 100644 index 000000000000..5db04832d644 --- /dev/null +++ b/test/files/run/t6988.check @@ -0,0 +1,2 @@ +#1 13 +#2 13 diff --git a/test/files/run/t6988.scala b/test/files/run/t6988.scala new file mode 100644 index 000000000000..45dfe33461d8 --- /dev/null +++ b/test/files/run/t6988.scala @@ -0,0 +1,9 @@ +case class User() + +@SerialVersionUID(13l) case class IdentifyMessage1(userName: String, user: User, code: Int) +@SerialVersionUID(10l + 3l) case class IdentifyMessage2(userName: String, user: User, code: Int) + +object Test extends App { + println("#1 " + java.io.ObjectStreamClass.lookup(IdentifyMessage1("hei", User(), 8).getClass).getSerialVersionUID) + println("#2 " + java.io.ObjectStreamClass.lookup(IdentifyMessage2("hei", User(), 8).getClass).getSerialVersionUID) +} From 51393167d8818986bb8971959d62cf5d58821c33 Mon Sep 17 00:00:00 2001 From: Tobias Roeser Date: Mon, 5 May 2014 21:50:36 +0200 Subject: [PATCH 214/826] Add JavaSE-1.7 to set of required execution environments. Without it, Equinox on Java 7 might spit out some warnings, which might lead to the wrong impression, that the Scala bundles are not well supported for newer platforms. --- src/build/bnd/scala-actors.bnd | 2 +- src/build/bnd/scala-compiler-doc.bnd | 3 +-- src/build/bnd/scala-compiler-interactive.bnd | 3 +-- src/build/bnd/scala-compiler.bnd | 3 +-- src/build/bnd/scala-continuations-library.bnd | 3 +-- src/build/bnd/scala-continuations-plugin.bnd | 3 +-- src/build/bnd/scala-library.bnd | 3 +-- src/build/bnd/scala-parser-combinators.bnd | 3 +-- src/build/bnd/scala-reflect.bnd | 3 +-- src/build/bnd/scala-swing.bnd | 3 +-- src/build/bnd/scala-xml.bnd | 3 +-- 11 files changed, 11 insertions(+), 21 deletions(-) diff --git a/src/build/bnd/scala-actors.bnd b/src/build/bnd/scala-actors.bnd index ea0ac52145c3..69885fc2bf7f 100644 --- a/src/build/bnd/scala-actors.bnd +++ b/src/build/bnd/scala-actors.bnd @@ -4,4 +4,4 @@ ver: @VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} Import-Package: scala.*;version="${range;[==,=+);${ver}}",* -Bundle-RequiredExecutionEnvironment: JavaSE-1.6 +Bundle-RequiredExecutionEnvironment: JavaSE-1.6, JavaSE-1.7 diff --git a/src/build/bnd/scala-compiler-doc.bnd b/src/build/bnd/scala-compiler-doc.bnd index a68c938315f8..9d6d0304d1f2 100644 --- a/src/build/bnd/scala-compiler-doc.bnd +++ b/src/build/bnd/scala-compiler-doc.bnd @@ -4,5 +4,4 @@ ver: @SCALA_COMPILER_DOC_VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} Import-Package: scala.*;version="${range;[==,=+);@VERSION@}",* -Bundle-RequiredExecutionEnvironment: JavaSE-1.6 - +Bundle-RequiredExecutionEnvironment: JavaSE-1.6, JavaSE-1.7 diff --git a/src/build/bnd/scala-compiler-interactive.bnd b/src/build/bnd/scala-compiler-interactive.bnd index 8869aeb81105..07e3de35b0cd 100644 --- a/src/build/bnd/scala-compiler-interactive.bnd +++ b/src/build/bnd/scala-compiler-interactive.bnd @@ -4,5 +4,4 @@ ver: @SCALA_COMPILER_INTERACTIVE_VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} Import-Package: scala.*;version="${range;[==,=+);@VERSION@}",* -Bundle-RequiredExecutionEnvironment: JavaSE-1.6 - +Bundle-RequiredExecutionEnvironment: JavaSE-1.6, JavaSE-1.7 diff --git a/src/build/bnd/scala-compiler.bnd b/src/build/bnd/scala-compiler.bnd index 98b743b2afc2..35201dd354e1 100644 --- a/src/build/bnd/scala-compiler.bnd +++ b/src/build/bnd/scala-compiler.bnd @@ -9,5 +9,4 @@ Import-Package: jline.*;resolution:=optional, \ scala.xml.*;version="${range;[===,=+);@XML_VERSION@}", \ scala.*;version="${range;[==,=+);${ver}}", \ * -Bundle-RequiredExecutionEnvironment: JavaSE-1.6 - +Bundle-RequiredExecutionEnvironment: JavaSE-1.6, JavaSE-1.7 diff --git a/src/build/bnd/scala-continuations-library.bnd b/src/build/bnd/scala-continuations-library.bnd index 6d81973438bc..b36718cc5b46 100644 --- a/src/build/bnd/scala-continuations-library.bnd +++ b/src/build/bnd/scala-continuations-library.bnd @@ -4,5 +4,4 @@ ver: @CONTINUATIONS_LIBRARY_VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} Import-Package: scala.*;version="${range;[==,=+);@VERSION@}",* -Bundle-RequiredExecutionEnvironment: JavaSE-1.6 - +Bundle-RequiredExecutionEnvironment: JavaSE-1.6, JavaSE-1.7 diff --git a/src/build/bnd/scala-continuations-plugin.bnd b/src/build/bnd/scala-continuations-plugin.bnd index 40ea2e85112b..2f2464b4529a 100644 --- a/src/build/bnd/scala-continuations-plugin.bnd +++ b/src/build/bnd/scala-continuations-plugin.bnd @@ -4,5 +4,4 @@ ver: @CONTINUATIONS_PLUGIN_VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} Import-Package: scala.*;version="${range;[==,=+);@VERSION@}",* -Bundle-RequiredExecutionEnvironment: JavaSE-1.6 - +Bundle-RequiredExecutionEnvironment: JavaSE-1.6, JavaSE-1.7 diff --git a/src/build/bnd/scala-library.bnd b/src/build/bnd/scala-library.bnd index ff78c5270111..7eb4fa4b2aa1 100644 --- a/src/build/bnd/scala-library.bnd +++ b/src/build/bnd/scala-library.bnd @@ -4,5 +4,4 @@ ver: @VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} Import-Package: sun.misc;resolution:=optional, * -Bundle-RequiredExecutionEnvironment: JavaSE-1.6 - +Bundle-RequiredExecutionEnvironment: JavaSE-1.6, JavaSE-1.7 diff --git a/src/build/bnd/scala-parser-combinators.bnd b/src/build/bnd/scala-parser-combinators.bnd index bdaff5fb0d11..ef8646cbd0a3 100644 --- a/src/build/bnd/scala-parser-combinators.bnd +++ b/src/build/bnd/scala-parser-combinators.bnd @@ -4,5 +4,4 @@ ver: @PARSER_COMBINATORS_VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} Import-Package: scala.*;version="${range;[==,=+);@VERSION@}",* -Bundle-RequiredExecutionEnvironment: JavaSE-1.6 - +Bundle-RequiredExecutionEnvironment: JavaSE-1.6, JavaSE-1.7 diff --git a/src/build/bnd/scala-reflect.bnd b/src/build/bnd/scala-reflect.bnd index a8afca4af0b9..e4bc54e52ed6 100644 --- a/src/build/bnd/scala-reflect.bnd +++ b/src/build/bnd/scala-reflect.bnd @@ -6,5 +6,4 @@ Export-Package: *;version=${ver} Import-Package: scala.*;version="${range;[==,=+);${ver}}", \ scala.tools.nsc;resolution:=optional;version="${range;[==,=+);${ver}}", \ * -Bundle-RequiredExecutionEnvironment: JavaSE-1.6 - +Bundle-RequiredExecutionEnvironment: JavaSE-1.6, JavaSE-1.7 diff --git a/src/build/bnd/scala-swing.bnd b/src/build/bnd/scala-swing.bnd index 62e198dc3466..f8b50baa9190 100644 --- a/src/build/bnd/scala-swing.bnd +++ b/src/build/bnd/scala-swing.bnd @@ -4,5 +4,4 @@ ver: @SCALA_SWING_VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} Import-Package: scala.*;version="${range;[==,=+);@VERSION@}",* -Bundle-RequiredExecutionEnvironment: JavaSE-1.6 - +Bundle-RequiredExecutionEnvironment: JavaSE-1.6,JavaSE-1.7 diff --git a/src/build/bnd/scala-xml.bnd b/src/build/bnd/scala-xml.bnd index 2789b0e01c1d..01bf0144eb56 100644 --- a/src/build/bnd/scala-xml.bnd +++ b/src/build/bnd/scala-xml.bnd @@ -4,5 +4,4 @@ ver: @XML_VERSION@ Bundle-Version: ${ver} Export-Package: *;version=${ver} Import-Package: scala.*;version="${range;[==,=+);@VERSION@}",* -Bundle-RequiredExecutionEnvironment: JavaSE-1.6 - +Bundle-RequiredExecutionEnvironment: JavaSE-1.6, JavaSE-1.7 From 87e2d7ff7663ab2b73c9bfdbec9a0aa287e3c9d2 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Tue, 6 May 2014 13:20:04 +0200 Subject: [PATCH 215/826] Bump version for 2.12.x For this step, we still depend on _2.11 libraries (partest, xml, parser-combinators). After we release the first milestone of 2.12, we will update versions.property to bootstrap to 2.12 dependencies. --- build.number | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/build.number b/build.number index 63a55339b983..142ae5027d39 100644 --- a/build.number +++ b/build.number @@ -1,7 +1,7 @@ #Tue Sep 11 19:21:09 CEST 2007 version.major=2 -version.minor=11 -version.patch=1 +version.minor=12 +version.patch=0 # This is the -N part of a version. if it's 0, it's dropped from maven versions. version.bnum=0 From 9c69956bfb96f9a30f3dc1f09909bff6b7dcf56e Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Tue, 6 May 2014 18:37:41 +0200 Subject: [PATCH 216/826] Disable MiMa on the 2.12.x branch --- build.xml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/build.xml b/build.xml index a66c138cbe32..d1a4bf3e7873 100755 --- a/build.xml +++ b/build.xml @@ -1523,8 +1523,9 @@ TODO: - - + + + - + From 10d77e905bf631ab7a7ade9e7a6b6d5abf2596f4 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Fri, 2 May 2014 15:31:07 +0200 Subject: [PATCH 219/826] Respect -Dpartest.scalac_opts when running the test suite through ANT Used to enable `-Xcheckinit` (now also `-Ybackend:GenBCode`) when compiling tests in the respective jenkins builds. This is currently broken, as you can see in [recent build logs] [1], `-Xcheckinit` is missing: [partest] Scalac options are: -optimise Adds `.flags` files for macro tests (correct range positions not enforced) and for tests failing due to SI-8560 or SI-8562. [1]: https://scala-webapps.epfl.ch/jenkins/view/nightlies/job/scala-nightly-checkinit/2058/consoleFull --- build-ant-macros.xml | 2 +- src/partest-extras/scala/tools/partest/BytecodeTest.scala | 2 +- test/files/pos/dotless-targs.flags | 1 + test/files/run/applydynamic_sip.flags | 1 + test/files/run/interop_typetags_are_manifests.flags | 1 + test/files/run/macro-openmacros.flags | 3 ++- test/files/run/macro-parse-position.flags | 1 + test/files/run/macroPlugins-macroExpand.flags | 1 + test/files/run/macroPlugins-typedMacroBody.flags | 1 + test/files/run/t6327.flags | 1 + test/files/run/t6663.flags | 1 + test/files/run/t6731.flags | 1 + test/files/run/virtpatmat_staging.flags | 1 + 13 files changed, 14 insertions(+), 3 deletions(-) create mode 100644 test/files/pos/dotless-targs.flags create mode 100644 test/files/run/interop_typetags_are_manifests.flags create mode 100644 test/files/run/macro-parse-position.flags create mode 100644 test/files/run/macroPlugins-macroExpand.flags create mode 100644 test/files/run/macroPlugins-typedMacroBody.flags create mode 100644 test/files/run/t6327.flags create mode 100644 test/files/run/t6663.flags create mode 100644 test/files/run/t6731.flags diff --git a/build-ant-macros.xml b/build-ant-macros.xml index ea5652770e1e..bd0e723b9b4b 100644 --- a/build-ant-macros.xml +++ b/build-ant-macros.xml @@ -745,7 +745,7 @@ - + diff --git a/src/partest-extras/scala/tools/partest/BytecodeTest.scala b/src/partest-extras/scala/tools/partest/BytecodeTest.scala index 7650a892fd7f..1e4362fcde73 100644 --- a/src/partest-extras/scala/tools/partest/BytecodeTest.scala +++ b/src/partest-extras/scala/tools/partest/BytecodeTest.scala @@ -34,7 +34,7 @@ abstract class BytecodeTest extends ASMConverters { /** produce the output to be compared against a checkfile */ protected def show(): Unit - def main(args: Array[String]): Unit = show + def main(args: Array[String]): Unit = show() // asserts def sameBytecode(methA: MethodNode, methB: MethodNode) = { diff --git a/test/files/pos/dotless-targs.flags b/test/files/pos/dotless-targs.flags new file mode 100644 index 000000000000..ea7fc37e1af3 --- /dev/null +++ b/test/files/pos/dotless-targs.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/run/applydynamic_sip.flags b/test/files/run/applydynamic_sip.flags index 1141f975075d..ba6d37305e99 100644 --- a/test/files/run/applydynamic_sip.flags +++ b/test/files/run/applydynamic_sip.flags @@ -1 +1,2 @@ +-Yrangepos:false -language:dynamics diff --git a/test/files/run/interop_typetags_are_manifests.flags b/test/files/run/interop_typetags_are_manifests.flags new file mode 100644 index 000000000000..ea7fc37e1af3 --- /dev/null +++ b/test/files/run/interop_typetags_are_manifests.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/run/macro-openmacros.flags b/test/files/run/macro-openmacros.flags index cd66464f2f63..2433c055a48f 100644 --- a/test/files/run/macro-openmacros.flags +++ b/test/files/run/macro-openmacros.flags @@ -1 +1,2 @@ --language:experimental.macros \ No newline at end of file +-Yrangepos:false +-language:experimental.macros diff --git a/test/files/run/macro-parse-position.flags b/test/files/run/macro-parse-position.flags new file mode 100644 index 000000000000..ea7fc37e1af3 --- /dev/null +++ b/test/files/run/macro-parse-position.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/run/macroPlugins-macroExpand.flags b/test/files/run/macroPlugins-macroExpand.flags new file mode 100644 index 000000000000..ea7fc37e1af3 --- /dev/null +++ b/test/files/run/macroPlugins-macroExpand.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/run/macroPlugins-typedMacroBody.flags b/test/files/run/macroPlugins-typedMacroBody.flags new file mode 100644 index 000000000000..ea7fc37e1af3 --- /dev/null +++ b/test/files/run/macroPlugins-typedMacroBody.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/run/t6327.flags b/test/files/run/t6327.flags new file mode 100644 index 000000000000..ea7fc37e1af3 --- /dev/null +++ b/test/files/run/t6327.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/run/t6663.flags b/test/files/run/t6663.flags new file mode 100644 index 000000000000..ea7fc37e1af3 --- /dev/null +++ b/test/files/run/t6663.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/run/t6731.flags b/test/files/run/t6731.flags new file mode 100644 index 000000000000..ea7fc37e1af3 --- /dev/null +++ b/test/files/run/t6731.flags @@ -0,0 +1 @@ +-Yrangepos:false diff --git a/test/files/run/virtpatmat_staging.flags b/test/files/run/virtpatmat_staging.flags index 48fd867160ba..0a22f7c729cc 100644 --- a/test/files/run/virtpatmat_staging.flags +++ b/test/files/run/virtpatmat_staging.flags @@ -1 +1,2 @@ +-Yrangepos:false -Xexperimental From 1ba2d7bb967ded0c19ff2cf966c492adc12292bb Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Tue, 29 Apr 2014 14:38:35 +0200 Subject: [PATCH 220/826] SI-8546 Pattern matcher analysis foiled by over-widening In the enclosed test, the prefix checkable type `ModuleTypeRef(F2.this, C)` was being inadvertently widened to `ModuleTypeRef(F2[?], C)`. This started after some misguided future-proofing in SI-6771 / 3009916. This commit changes the `dealiasWiden` to a `delias`. --- .../nsc/transform/patmat/MatchAnalysis.scala | 5 +- test/files/neg/t6771b.check | 2 +- test/files/neg/t6771b.scala | 2 - test/files/pos/t8546.flags | 1 + test/files/pos/t8546.scala | 49 +++++++++++++++++++ 5 files changed, 54 insertions(+), 5 deletions(-) create mode 100644 test/files/pos/t8546.flags create mode 100644 test/files/pos/t8546.scala diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala index 2893cbdf450e..894f959319a8 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala @@ -149,14 +149,15 @@ trait TreeAndTypeAnalysis extends Debugging { object typeArgsToWildcardsExceptArray extends TypeMap { // SI-6771 dealias would be enough today, but future proofing with the dealiasWiden. // See neg/t6771b.scala for elaboration - def apply(tp: Type): Type = tp.dealiasWiden match { + def apply(tp: Type): Type = tp.dealias match { case TypeRef(pre, sym, args) if args.nonEmpty && (sym ne ArrayClass) => TypeRef(pre, sym, args map (_ => WildcardType)) case _ => mapOver(tp) } } - debug.patmatResult(s"checkableType($tp)")(typeArgsToWildcardsExceptArray(tp)) + val result = typeArgsToWildcardsExceptArray(tp) + debug.patmatResult(s"checkableType($tp)")(result) } // a type is "uncheckable" (for exhaustivity) if we don't statically know its subtypes (i.e., it's unsealed) diff --git a/test/files/neg/t6771b.check b/test/files/neg/t6771b.check index ba99e9178d75..0c9fae533e28 100644 --- a/test/files/neg/t6771b.check +++ b/test/files/neg/t6771b.check @@ -1,4 +1,4 @@ -t6771b.scala:14: error: type mismatch; +t6771b.scala:12: error: type mismatch; found : x.type (with underlying type String) required: Test.a.type b = b match { case x => x } diff --git a/test/files/neg/t6771b.scala b/test/files/neg/t6771b.scala index 78f11f7750bd..9723f7029026 100644 --- a/test/files/neg/t6771b.scala +++ b/test/files/neg/t6771b.scala @@ -6,8 +6,6 @@ // But, to the intrepid hacker who works on this, a few notes: // You'll have to look into places in the pattern matcher that // call `dealias`, and see if they need to be `dealiasWiden`. -// For example, if `checkableType` used only `dealias`, `pos/t6671.scala` -// would fail. object Test { val a = ""; var b: a.type = a diff --git a/test/files/pos/t8546.flags b/test/files/pos/t8546.flags new file mode 100644 index 000000000000..85d8eb2ba295 --- /dev/null +++ b/test/files/pos/t8546.flags @@ -0,0 +1 @@ +-Xfatal-warnings diff --git a/test/files/pos/t8546.scala b/test/files/pos/t8546.scala new file mode 100644 index 000000000000..c39d749b4c45 --- /dev/null +++ b/test/files/pos/t8546.scala @@ -0,0 +1,49 @@ +package test + +class F1() { + private sealed abstract class T + private case class A(m: Int) extends T + private case class B() extends T + private case object C extends T + + // No warnings here + private def foo(t: T) = t match { + case A(m) => println("A:" + m) + case B() => println("B") + case C => println("C") + } + + def test(m: Int): Unit = { + foo(A(m)) + foo(B()) + foo(C) + } +} + +class F2[M]() { + private sealed abstract class T + private case class A(m: M) extends T + private case class B() extends T + private case object C extends T + + // match may not be exhaustive. It would fail on the following input: C + private def foo(t: T) = t match { + case A(m) => println("A:" + m) + case B() => println("B") + case C => println("C") + } + + def test(m: M): Unit = { + foo(A(m)) + foo(B()) + foo(C) + } + +} + +object Test { + def main(args: Array[String]): Unit = { + new F1().test(1) + new F2[Int]().test(1) + } +} \ No newline at end of file From 840234017bc6b8a3610c208883fd6ad5a563fcd3 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Wed, 7 May 2014 17:48:59 +0200 Subject: [PATCH 221/826] SI-7852 for GenBCode Avoid null checks for "someLiteral".== and SomeModule.==. This has been implemented in GenICode in #2954. Introduces a trait to share code between GenICode and GenBCode. This is just a start, more such refactorings will come quite certainly. --- .../tools/nsc/backend/icode/GenICode.scala | 12 +-------- .../nsc/backend/jvm/BCodeBodyBuilder.scala | 17 +++++------- .../tools/nsc/backend/jvm/BCodeGlue.scala | 2 +- .../nsc/backend/jvm/BCodeICodeCommon.scala | 26 +++++++++++++++++++ test/files/run/t7852.scala | 2 +- 5 files changed, 35 insertions(+), 24 deletions(-) create mode 100644 src/compiler/scala/tools/nsc/backend/jvm/BCodeICodeCommon.scala diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala index 1cea4beddae0..e1183d8403ac 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala @@ -13,13 +13,12 @@ import scala.collection.{ mutable, immutable } import scala.collection.mutable.{ ListBuffer, Buffer } import scala.tools.nsc.symtab._ import scala.annotation.switch -import PartialFunction._ /** * @author Iulian Dragos * @version 1.0 */ -abstract class GenICode extends SubComponent { +abstract class GenICode extends SubComponent with jvm.BCodeICodeCommon { import global._ import icodes._ import icodes.opcodes._ @@ -1326,15 +1325,6 @@ abstract class GenICode extends SubComponent { List(tree) } - /** Some useful equality helpers. - */ - def isNull(t: Tree) = cond(t) { case Literal(Constant(null)) => true } - def isLiteral(t: Tree) = cond(t) { case Literal(_) => true } - def isNonNullExpr(t: Tree) = isLiteral(t) || ((t.symbol ne null) && t.symbol.isModule) - - /* If l or r is constant null, returns the other ; otherwise null */ - def ifOneIsNull(l: Tree, r: Tree) = if (isNull(l)) r else if (isNull(r)) l else null - /** * Find the label denoted by `lsym` and enter it in context `ctx`. * diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index 53142fbd8760..9e27373a07ef 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -1020,17 +1020,6 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { tree :: Nil } - /* Some useful equality helpers. */ - def isNull(t: Tree) = { - t match { - case Literal(Constant(null)) => true - case _ => false - } - } - - /* If l or r is constant null, returns the other ; otherwise null */ - def ifOneIsNull(l: Tree, r: Tree) = if (isNull(l)) r else if (isNull(r)) l else null - /* Emit code to compare the two top-most stack values using the 'op' operator. */ private def genCJUMP(success: asm.Label, failure: asm.Label, op: TestOp, tk: BType) { if (tk.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT @@ -1200,6 +1189,12 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { // expr == null -> expr eq null genLoad(l, ObjectReference) genCZJUMP(success, failure, icodes.EQ, ObjectReference) + } else if (isNonNullExpr(l)) { + // SI-7852 Avoid null check if L is statically non-null. + genLoad(l, ObjectReference) + genLoad(r, ObjectReference) + genCallMethod(Object_equals, icodes.opcodes.Dynamic) + genCZJUMP(success, failure, icodes.NE, BOOL) } else { // l == r -> if (l eq null) r eq null else l.equals(r) val eqEqTempLocal = locals.makeLocal(AnyRefReference, nme.EQEQ_LOCAL_VAR.toString) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala index cc3265c5f9fb..ef116324bf7b 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala @@ -18,7 +18,7 @@ import scala.collection.{ immutable, mutable } * @version 1.0 * */ -abstract class BCodeGlue extends SubComponent { +abstract class BCodeGlue extends SubComponent with BCodeICodeCommon { import global._ diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeICodeCommon.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeICodeCommon.scala new file mode 100644 index 000000000000..071e0cf74c4a --- /dev/null +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeICodeCommon.scala @@ -0,0 +1,26 @@ +/* NSC -- new Scala compiler + * Copyright 2005-2014 LAMP/EPFL + * @author Martin Odersky + */ + +package scala.tools.nsc.backend.jvm + +import scala.tools.nsc.Global +import PartialFunction._ + +/** + * This trait contains code shared between GenBCode and GenICode that depends on types defined in + * the compiler cake (Global). + */ +trait BCodeICodeCommon { + val global: Global + import global._ + + /** Some useful equality helpers. */ + def isNull(t: Tree) = cond(t) { case Literal(Constant(null)) => true } + def isLiteral(t: Tree) = cond(t) { case Literal(_) => true } + def isNonNullExpr(t: Tree) = isLiteral(t) || ((t.symbol ne null) && t.symbol.isModule) + + /** If l or r is constant null, returns the other ; otherwise null */ + def ifOneIsNull(l: Tree, r: Tree) = if (isNull(l)) r else if (isNull(r)) l else null +} diff --git a/test/files/run/t7852.scala b/test/files/run/t7852.scala index c93db718fded..167906751042 100644 --- a/test/files/run/t7852.scala +++ b/test/files/run/t7852.scala @@ -12,7 +12,7 @@ object Test extends BytecodeTest { val classNode = loadClassNode("Lean") val methodNode = getMethod(classNode, methodName) val got = countNullChecks(methodNode.instructions) - assert(got == expected, s"expected $expected but got $got comparisons") + assert(got == expected, s"$methodName: expected $expected but got $got comparisons") } test("string", expected = 0) test("module", expected = 0) From b185cbdeeda030df11a9459eb53c426a9c9a4555 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Wed, 7 May 2014 09:14:57 -0700 Subject: [PATCH 222/826] SI-8325 Spec accepts infix type * Remove the clause in 3.2.8 that reserves `*` as a postfix modifier thing. For emphasis, the language that an infix type name can be an arbitrary identifier is retained, sans buts. --- spec/03-types.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/spec/03-types.md b/spec/03-types.md index 66ddee8b7e0b..4a02c7a8c1f3 100644 --- a/spec/03-types.md +++ b/spec/03-types.md @@ -352,8 +352,7 @@ An infix type $T_1$ `op` $T_2$ consists of an infix operator `op` which gets applied to two type operands $T_1$ and $T_2$. The type is equivalent to the type application `op`$[T_1, T_2]$. The infix operator `op` may be an -arbitrary identifier, except for `*`, which is reserved as a postfix modifier -denoting a [repeated parameter type](04-basic-declarations-and-definitions.html#repeated-parameters). +arbitrary identifier. All type infix operators have the same precedence; parentheses have to be used for grouping. The [associativity](06-expressions.html#prefix-infix-and-postfix-operations) From bab17406352fcde2f91eccbe160f98dd40e3b518 Mon Sep 17 00:00:00 2001 From: Grzegorz Kossakowski Date: Wed, 7 May 2014 20:02:58 +0200 Subject: [PATCH 223/826] Make partest to depend on Scala compiler Eclipse project. This way changes made to Scala compiler sources are visible to partest in Eclipse. --- src/eclipse/partest/.classpath | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/eclipse/partest/.classpath b/src/eclipse/partest/.classpath index c2aab19f1890..7f28868d95ee 100644 --- a/src/eclipse/partest/.classpath +++ b/src/eclipse/partest/.classpath @@ -4,11 +4,11 @@ - + - - + + From a4151c0950c9155a1cf470b8b9c92029cc9ce604 Mon Sep 17 00:00:00 2001 From: Grzegorz Kossakowski Date: Wed, 7 May 2014 21:53:18 +0200 Subject: [PATCH 224/826] Get rid of Platform.doLoad method. Since .NET backend got removed this method is a no-op. --- src/compiler/scala/tools/nsc/backend/JavaPlatform.scala | 2 -- src/compiler/scala/tools/nsc/backend/Platform.scala | 8 -------- src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala | 2 +- 3 files changed, 1 insertion(+), 11 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/JavaPlatform.scala b/src/compiler/scala/tools/nsc/backend/JavaPlatform.scala index 32b5a98b9865..7236bf70d5b3 100644 --- a/src/compiler/scala/tools/nsc/backend/JavaPlatform.scala +++ b/src/compiler/scala/tools/nsc/backend/JavaPlatform.scala @@ -55,8 +55,6 @@ trait JavaPlatform extends Platform { (sym isNonBottomSubClass BoxedBooleanClass) } - def doLoad(cls: ClassPath[AbstractFile]#ClassRep): Boolean = true - def needCompile(bin: AbstractFile, src: AbstractFile) = src.lastModified >= bin.lastModified } diff --git a/src/compiler/scala/tools/nsc/backend/Platform.scala b/src/compiler/scala/tools/nsc/backend/Platform.scala index 499f8a9290c1..439cc1efb806 100644 --- a/src/compiler/scala/tools/nsc/backend/Platform.scala +++ b/src/compiler/scala/tools/nsc/backend/Platform.scala @@ -30,14 +30,6 @@ trait Platform { /** The various ways a boxed primitive might materialize at runtime. */ def isMaybeBoxed(sym: Symbol): Boolean - /** - * Tells whether a class should be loaded and entered into the package - * scope. On .NET, this method returns `false` for all synthetic classes - * (anonymous classes, implementation classes, module classes), their - * symtab is encoded in the pickle of another class. - */ - def doLoad(cls: ClassPath[AbstractFile]#ClassRep): Boolean - /** * Tells whether a class with both a binary and a source representation * (found in classpath and in sourcepath) should be re-compiled. Behaves diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala index 8b739958ff0a..447fa66ae4ea 100644 --- a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala +++ b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala @@ -251,7 +251,7 @@ abstract class SymbolLoaders { root.setInfo(new PackageClassInfoType(newScope, root)) if (!root.isRoot) { - for (classRep <- classpath.classes if platform.doLoad(classRep)) { + for (classRep <- classpath.classes) { initializeFromClassPath(root, classRep) } } From f52d31f1ffd90506934ab31aff3c50b9d24d6ec6 Mon Sep 17 00:00:00 2001 From: Grzegorz Kossakowski Date: Wed, 7 May 2014 22:50:30 +0200 Subject: [PATCH 225/826] Refactor FastTrack to use composition instead of inheritance. Instead of mixing in FastTrack into Macros trait just have a member with an instance of FastTrack. The motivation for this change is to reduce the overall use of inheritance is Scala compiler and FastTrack seems like a nice target for first step. It's an implementation detail of Scala compiler that we are free to modify. Previously, `fastTrack` method would be inherited from FastTrack trait and called from clients (sub classes). The `fastTrack` method returned Map. Now, the `fastTrack` viariable is of type `FastTrack`. In order for clients to continue to work we had to implement three operations called by clients: contains, apply, get. Alternatively, we could keep the `fastTrack` method and import it in clients. This approach is likely to be more common in the future when bigger pieces of code get refactored. --- src/compiler/scala/tools/nsc/typechecker/Macros.scala | 4 +++- src/compiler/scala/tools/reflect/FastTrack.scala | 9 ++++++--- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala index 9cf92ca5b943..f4456998c05c 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala @@ -42,7 +42,7 @@ import Fingerprint._ * (Expr(elems)) * (TypeTag(Int)) */ -trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers { +trait Macros extends MacroRuntimes with Traces with Helpers { self: Analyzer => import global._ @@ -50,6 +50,8 @@ trait Macros extends FastTrack with MacroRuntimes with Traces with Helpers { import treeInfo.{isRepeatedParamType => _, _} import MacrosStats._ + lazy val fastTrack = new FastTrack[self.type](self) + def globalSettings = global.settings protected def findMacroClassLoader(): ClassLoader = { diff --git a/src/compiler/scala/tools/reflect/FastTrack.scala b/src/compiler/scala/tools/reflect/FastTrack.scala index 8630ecf69eaa..64cf3d0847f0 100644 --- a/src/compiler/scala/tools/reflect/FastTrack.scala +++ b/src/compiler/scala/tools/reflect/FastTrack.scala @@ -10,14 +10,18 @@ import scala.tools.reflect.quasiquotes.{ Quasiquotes => QuasiquoteImpls } /** Optimizes system macro expansions by hardwiring them directly to their implementations * bypassing standard reflective load and invoke to avoid the overhead of Java/Scala reflection. */ -trait FastTrack { - self: Macros with Analyzer => +class FastTrack[MacrosAndAnalyzer <: Macros with Analyzer](val macros: MacrosAndAnalyzer) { + import macros._ import global._ import definitions._ import scala.language.implicitConversions import treeInfo.Applied + def contains(symbol: Symbol): Boolean = fastTrackCache().contains(symbol) + def apply(symbol: Symbol): FastTrackEntry = fastTrackCache().apply(symbol) + def get(symbol: Symbol): Option[FastTrackEntry] = fastTrackCache().get(symbol) + private implicit def context2taggers(c0: MacroContext): Taggers { val c: c0.type } = new { val c: c0.type = c0 } with Taggers private implicit def context2macroimplementations(c0: MacroContext): FormatInterpolator { val c: c0.type } = @@ -39,7 +43,6 @@ trait FastTrack { } /** A map from a set of pre-established macro symbols to their implementations. */ - def fastTrack: Map[Symbol, FastTrackEntry] = fastTrackCache() private val fastTrackCache = perRunCaches.newGeneric[Map[Symbol, FastTrackEntry]] { val runDefinitions = currentRun.runDefinitions import runDefinitions._ From cee2ad219d4ae2f499fc4cae93edb723c17e3c2c Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 8 May 2014 10:22:02 +0200 Subject: [PATCH 226/826] Disable 'unreachable' test for GenBCode GenICode has some logic to eliminate some dead code directly at code gen (introduced in b50a0d811f for SI-7006). This has not been ported over to GenBCode. GenBCode with the new optimizer (in Miguel's branch) also eliminates such dead code. Before adding such functionality to GenBCode I'd like to investigate the cost of running DCE. Maybe we can keep the code generator simple. I created SI-8568 to keep track of this. --- test/files/jvm/unreachable.flags | 1 + 1 file changed, 1 insertion(+) create mode 100644 test/files/jvm/unreachable.flags diff --git a/test/files/jvm/unreachable.flags b/test/files/jvm/unreachable.flags new file mode 100644 index 000000000000..49f2d2c4c833 --- /dev/null +++ b/test/files/jvm/unreachable.flags @@ -0,0 +1 @@ +-Ybackend:GenASM From b154269b0e7447cfbf7fdb73c8c4efcdca545b11 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Thu, 24 Apr 2014 10:53:20 +0200 Subject: [PATCH 227/826] SI-8531 Better space efficiency for patmat analysis By adding logging to `clause`, I found that the majority of calls provide 0 or 1 elements. In SI-7020 / 69557da55, we changed this method to use a `LinkedHashSet` to have deterministic results for clauses with more elements. But I suspect that this contributes to higher memory usage from the pattern matcher. The enclosed test case, carefully whittled down by @oxbowlakes, used to consume an inordinate amount of memory and time. After this patch, it is back to 2.10.4 performance. I have run `neg/t7020.scala` in a loop and it still is deterministic. --- .../tools/nsc/transform/patmat/Solving.scala | 8 +++++-- test/files/pos/t8531/MyEnum.java | 5 ++++ test/files/pos/t8531/Test.scala | 24 +++++++++++++++++++ 3 files changed, 35 insertions(+), 2 deletions(-) create mode 100644 test/files/pos/t8531/MyEnum.java create mode 100644 test/files/pos/t8531/Test.scala diff --git a/src/compiler/scala/tools/nsc/transform/patmat/Solving.scala b/src/compiler/scala/tools/nsc/transform/patmat/Solving.scala index 1902606d860e..31b1ffa912a2 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/Solving.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/Solving.scala @@ -29,8 +29,12 @@ trait Solving extends Logic { type Clause = collection.Set[Lit] // a clause is a disjunction of distinct literals def clause(l: Lit*): Clause = ( - // neg/t7020.scala changes output 1% of the time, the non-determinism is quelled with this linked set - mutable.LinkedHashSet(l: _*) + if (l.lengthCompare(1) <= 0) { + l.toSet // SI-8531 Avoid LinkedHashSet's bulk for 0 and 1 element clauses + } else { + // neg/t7020.scala changes output 1% of the time, the non-determinism is quelled with this linked set + mutable.LinkedHashSet(l: _*) + } ) type Lit diff --git a/test/files/pos/t8531/MyEnum.java b/test/files/pos/t8531/MyEnum.java new file mode 100644 index 000000000000..06cc128a796e --- /dev/null +++ b/test/files/pos/t8531/MyEnum.java @@ -0,0 +1,5 @@ + +package foobar; +public enum MyEnum { +A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64, A65, A66, A67, A68, A69, A70, A71, A72, A73, A74, A75, A76, A77, A78, A79, A80, A81, A82, A83, A84, A85, A86, A87, A88, A89, A90, A91, A92, A93, A94, A95, A96, A97, A98, A99, A100, A101, A102, A103, A104, A105, A106, A107, A108, A109, A110, A111, A112, A113, A114, A115, A116, A117, A118, A119, A120, A121, A122, A123, A124, A125, A126, A127, A128, A129, A130, A131, A132, A133, A134, A135, A136, A137, A138, A139, A140, A141, A142, A143, A144, A145, A146, A147, A148, A149, A150, A151, A152, A153, A154, A155, A156, A157, A158, A159, A160, A161, A162, A163, A164, A165, A166, A167, A168, A169, A170, A171, A172, A173, A174, A175, A176, A177, A178, A179, A180, A181, A182, A183, A184, A185, A186, A187, A188, A189, A190, A191, A192, A193; +} diff --git a/test/files/pos/t8531/Test.scala b/test/files/pos/t8531/Test.scala new file mode 100644 index 000000000000..59861435a6b7 --- /dev/null +++ b/test/files/pos/t8531/Test.scala @@ -0,0 +1,24 @@ +package test + +// takes > 50s and > 800M heap to compile under 2.11.0 +import foobar._ +class `SI-8531` { + //https://issues.scala-lang.org/browse/SI-8531 + + import MyEnum._ + def foo(e1: MyEnum, e2: MyEnum) = (e1, e2) match { + case (A1, x) => "a1" + case (x, A1) => "a1" + case (A2, x) => "a2" + case (x, A2) => "a2" + case (A3, x) => "a3" + case (x, A3) => "a3" + case (A4, x) => "a4" + case (x, A4) => "a4" + case (A5, x) => "a5" + case (x, A5) => "a5" + case (A6, x) => "a6" + case (x, A6) => "a6" + case (a, b) => "ab" + } +} From 7375f8e013ced92c6280c551af1c707122cc53f7 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 8 May 2014 11:05:33 +0200 Subject: [PATCH 228/826] Fix run/t3569.scala under checkinit --- test/files/run/t3569.scala | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/files/run/t3569.scala b/test/files/run/t3569.scala index 91d437e0e351..eb3b424439e9 100644 --- a/test/files/run/t3569.scala +++ b/test/files/run/t3569.scala @@ -26,7 +26,8 @@ object Test { s.x += 1 println(s.x) - (classOf[X].getDeclaredFields map ("" + _)).sorted foreach println + // under -Xcheckinit there's an additional $init$ field + (classOf[X].getDeclaredFields map ("" + _)).sorted.filter(_ != "private volatile byte Test$X.bitmap$init$0") foreach println (classOf[Y].getDeclaredFields map ("" + _)).sorted foreach println } } From 908ccd9feea072b4ed249db5f2741f745b42ca75 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 8 May 2014 11:11:09 +0200 Subject: [PATCH 229/826] Fix run/t5256h.scala under checkinit --- test/files/run/t5256h.scala | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/files/run/t5256h.scala b/test/files/run/t5256h.scala index f58aa6dbe742..435124a469f9 100644 --- a/test/files/run/t5256h.scala +++ b/test/files/run/t5256h.scala @@ -6,5 +6,6 @@ object Test extends App { val c = cm.classSymbol(mutant.getClass) println(c) println(c.fullName) - println(c.info) + // under -Xcheckinit there's an additional $init$ field + c.info.toString.lines.filter(_ != " private var bitmap$init$0: Boolean") foreach println } From 30610d53489478663a63a89ca09189e622024dc5 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 8 May 2014 15:34:28 +0200 Subject: [PATCH 230/826] BCodeICodeCommon through composition rather than inheritance --- src/compiler/scala/tools/nsc/backend/icode/GenICode.scala | 5 ++++- .../scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala | 1 + src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala | 4 +++- .../scala/tools/nsc/backend/jvm/BCodeICodeCommon.scala | 3 +-- 4 files changed, 9 insertions(+), 4 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala index e1183d8403ac..0da66d43f78c 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala @@ -18,7 +18,7 @@ import scala.annotation.switch * @author Iulian Dragos * @version 1.0 */ -abstract class GenICode extends SubComponent with jvm.BCodeICodeCommon { +abstract class GenICode extends SubComponent { import global._ import icodes._ import icodes.opcodes._ @@ -29,6 +29,9 @@ abstract class GenICode extends SubComponent with jvm.BCodeICodeCommon { } import platform.isMaybeBoxed + private val bCodeICodeCommon: jvm.BCodeICodeCommon[global.type] = new jvm.BCodeICodeCommon(global) + import bCodeICodeCommon._ + val phaseName = "icode" override def newPhase(prev: Phase) = new ICodePhase(prev) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index 9e27373a07ef..92ebe5027ac4 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -23,6 +23,7 @@ import scala.tools.asm abstract class BCodeBodyBuilder extends BCodeSkelBuilder { import global._ import definitions._ + import bCodeICodeCommon._ /* * Functionality to build the body of ASM MethodNode, except for `synchronized` and `try` expressions. diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala index ef116324bf7b..aa7e73a36b69 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala @@ -18,10 +18,12 @@ import scala.collection.{ immutable, mutable } * @version 1.0 * */ -abstract class BCodeGlue extends SubComponent with BCodeICodeCommon { +abstract class BCodeGlue extends SubComponent { import global._ + protected val bCodeICodeCommon: BCodeICodeCommon[global.type] = new BCodeICodeCommon(global) + object BType { import global.chrs diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeICodeCommon.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeICodeCommon.scala index 071e0cf74c4a..50d20921d50c 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeICodeCommon.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeICodeCommon.scala @@ -12,8 +12,7 @@ import PartialFunction._ * This trait contains code shared between GenBCode and GenICode that depends on types defined in * the compiler cake (Global). */ -trait BCodeICodeCommon { - val global: Global +final class BCodeICodeCommon[G <: Global](val global: G) { import global._ /** Some useful equality helpers. */ From 78bd175afcc89878ca1c00cce69d0517909c6ff3 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Wed, 7 May 2014 08:11:14 -0700 Subject: [PATCH 231/826] SI-5905 Clarify test case The language feature options are discovered reflectively, but it is nice to enforce that expected options are supplied. Short of that, the code string includes a rowdy postfix operator. It still does enforce that at least one option was discovered. Delete -nowarn flags file. Let's see if that was to suppress a warning in the standard build. --- test/files/run/t5905-features.flags | 1 - test/files/run/t5905-features.scala | 8 +++++--- 2 files changed, 5 insertions(+), 4 deletions(-) delete mode 100644 test/files/run/t5905-features.flags diff --git a/test/files/run/t5905-features.flags b/test/files/run/t5905-features.flags deleted file mode 100644 index ad51758c3932..000000000000 --- a/test/files/run/t5905-features.flags +++ /dev/null @@ -1 +0,0 @@ --nowarn diff --git a/test/files/run/t5905-features.scala b/test/files/run/t5905-features.scala index a3848eef2ae9..547a521cb5e6 100644 --- a/test/files/run/t5905-features.scala +++ b/test/files/run/t5905-features.scala @@ -3,13 +3,13 @@ import tools.partest.DirectTest // verify that all languageFeature names are accepted by -language object Test extends DirectTest { - override def code = "class Code { def f = (1 to 10) size }" // exercise a feature + override def code = "class Code { def f = (1 to 10) size }" // exercise a feature to sanity-check coverage of -language options override def extraSettings = s"-usejavacp -d ${testOutput.path}" override def show() = { - val global = newCompiler("-language:postfixOps", "-Ystop-after:typer") - compileString(global)(code) + val global = newCompiler("-Ystop-after:typer") + compileString(global)("") // warm me up, scotty import global._ exitingTyper { //def isFeature(s: Symbol) = s.annotations.exists((a: AnnotationInfo) => a.tpe <:< typeOf[scala.annotation.meta.languageFeature]) @@ -21,6 +21,8 @@ object Test extends DirectTest { assert(feats.nonEmpty, "Test must find feature flags.") + //compile("junk") // tragically, does not fail the test + //dynamics,postfixOps,reflectiveCalls,implicitConversions,higherKinds,existentials,experimental.macros compile(s"-language:$all") } From 4483085b9b66d7460468fd80c62b42c0b88a5e76 Mon Sep 17 00:00:00 2001 From: Tobias Roeser Date: Fri, 9 May 2014 16:14:39 +0200 Subject: [PATCH 232/826] Re-added the scala.util.parsing package import, with optional resolution. --- src/build/bnd/scala-compiler.bnd | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/build/bnd/scala-compiler.bnd b/src/build/bnd/scala-compiler.bnd index 745ffc117676..2bd24d780d7b 100644 --- a/src/build/bnd/scala-compiler.bnd +++ b/src/build/bnd/scala-compiler.bnd @@ -5,7 +5,7 @@ Bundle-Version: ${ver} Export-Package: *;version=${ver} Import-Package: jline.*;resolution:=optional, \ org.apache.tools.ant.*;resolution:=optional, \ - !scala.util.parsing.*, \ + scala.util.parsing.*;version="${range;[====,====];@PARSER_COMBINATORS_VERSION@}";resolution:=optional, \ scala.xml.*;version="${range;[====,====];@XML_VERSION@}";resolution:=optional, \ scala.*;version="${range;[==,=+);${ver}}", \ * From bdb1258d2ab8ff10d8e9f4924069a227ae82e690 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Fri, 9 May 2014 16:50:08 +0200 Subject: [PATCH 233/826] Revert "SI-5905 Clarify test case" This reverts commit 78bd175afcc89878ca1c00cce69d0517909c6ff3. See discussion: https://github.com/scala/scala/pull/3597#commitcomment-6270375 --- test/files/run/t5905-features.flags | 1 + test/files/run/t5905-features.scala | 8 +++----- 2 files changed, 4 insertions(+), 5 deletions(-) create mode 100644 test/files/run/t5905-features.flags diff --git a/test/files/run/t5905-features.flags b/test/files/run/t5905-features.flags new file mode 100644 index 000000000000..ad51758c3932 --- /dev/null +++ b/test/files/run/t5905-features.flags @@ -0,0 +1 @@ +-nowarn diff --git a/test/files/run/t5905-features.scala b/test/files/run/t5905-features.scala index 547a521cb5e6..a3848eef2ae9 100644 --- a/test/files/run/t5905-features.scala +++ b/test/files/run/t5905-features.scala @@ -3,13 +3,13 @@ import tools.partest.DirectTest // verify that all languageFeature names are accepted by -language object Test extends DirectTest { - override def code = "class Code { def f = (1 to 10) size }" // exercise a feature to sanity-check coverage of -language options + override def code = "class Code { def f = (1 to 10) size }" // exercise a feature override def extraSettings = s"-usejavacp -d ${testOutput.path}" override def show() = { - val global = newCompiler("-Ystop-after:typer") - compileString(global)("") // warm me up, scotty + val global = newCompiler("-language:postfixOps", "-Ystop-after:typer") + compileString(global)(code) import global._ exitingTyper { //def isFeature(s: Symbol) = s.annotations.exists((a: AnnotationInfo) => a.tpe <:< typeOf[scala.annotation.meta.languageFeature]) @@ -21,8 +21,6 @@ object Test extends DirectTest { assert(feats.nonEmpty, "Test must find feature flags.") - //compile("junk") // tragically, does not fail the test - //dynamics,postfixOps,reflectiveCalls,implicitConversions,higherKinds,existentials,experimental.macros compile(s"-language:$all") } From 71cfb57499bda80f5fb0a810f37d0f9c54e1afd3 Mon Sep 17 00:00:00 2001 From: Jean-Remi Desjardins Date: Mon, 5 May 2014 09:34:15 -0400 Subject: [PATCH 234/826] SI-8475 Fix off by one in GroupedIterator when Streaming This also affected sliding and grouped since they defer to GroupedIterator --- src/library/scala/collection/Iterator.scala | 4 +++- .../junit/scala/collection/IteratorTest.scala | 20 +++++++++++++++++++ 2 files changed, 23 insertions(+), 1 deletion(-) create mode 100644 test/junit/scala/collection/IteratorTest.scala diff --git a/src/library/scala/collection/Iterator.scala b/src/library/scala/collection/Iterator.scala index 1b496383a398..e321a6adbad8 100644 --- a/src/library/scala/collection/Iterator.scala +++ b/src/library/scala/collection/Iterator.scala @@ -926,7 +926,9 @@ trait Iterator[+A] extends TraversableOnce[A] { private def takeDestructively(size: Int): Seq[A] = { val buf = new ArrayBuffer[A] var i = 0 - while (self.hasNext && i < size) { + // The order of terms in the following condition is important + // here as self.hasNext could be blocking + while (i < size && self.hasNext) { buf += self.next i += 1 } diff --git a/test/junit/scala/collection/IteratorTest.scala b/test/junit/scala/collection/IteratorTest.scala new file mode 100644 index 000000000000..cb7cbb40bc2e --- /dev/null +++ b/test/junit/scala/collection/IteratorTest.scala @@ -0,0 +1,20 @@ + +package scala.collection + +import org.junit.Assert._ +import org.junit.Test +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 + +@RunWith(classOf[JUnit4]) +class IteratorTest { + + @Test + def groupedIteratorShouldNotAskForUnneededElement(): Unit = { + var counter = 0 + val it = new Iterator[Int] { var i = 0 ; def hasNext = { counter = i; true } ; def next = { i += 1; i } } + val slidingIt = it sliding 2 + slidingIt.next + assertEquals("Counter should be one, that means we didn't look further than needed", 1, counter) + } +} From e2fb217483d72b7c35d67377b165742a9209bb06 Mon Sep 17 00:00:00 2001 From: VladimirNik Date: Fri, 9 May 2014 20:50:39 +0400 Subject: [PATCH 235/826] TypeTree printing modified (SI-8447) --- .../scala/reflect/internal/Printers.scala | 41 ++++++---- .../scala/reflect/internal/PrintersTest.scala | 77 ++++++++++++------- 2 files changed, 78 insertions(+), 40 deletions(-) diff --git a/src/reflect/scala/reflect/internal/Printers.scala b/src/reflect/scala/reflect/internal/Printers.scala index fcc377ba3244..2ce861898f9f 100644 --- a/src/reflect/scala/reflect/internal/Printers.scala +++ b/src/reflect/scala/reflect/internal/Printers.scala @@ -596,18 +596,26 @@ trait Printers extends api.Printers { self: SymbolTable => } } - protected def emptyTree(tree: Tree) = tree match { - case EmptyTree | build.SyntacticEmptyTypeTree() => true - case _ => false + object EmptyTypeTree { + def unapply(tt: TypeTree): Boolean = tt match { + case build.SyntacticEmptyTypeTree() if tt.wasEmpty || tt.isEmpty => true + case _ => false + } } + protected def isEmptyTree(tree: Tree) = + tree match { + case EmptyTree | EmptyTypeTree() => true + case _ => false + } + protected def originalTypeTrees(trees: List[Tree]) = - trees.filter(!emptyTree(_)) map { - case tt: TypeTree => tt.original - case tree => tree + trees.filter(!isEmptyTree(_)) map { + case tt: TypeTree if tt.original != null => tt.original + case tree => tree } - val defaultClasses = List(tpnme.AnyRef) + val defaultClasses = List(tpnme.AnyRef, tpnme.Object) val defaultTraitsForCase = List(tpnme.Product, tpnme.Serializable) protected def removeDefaultTypesFromList(trees: List[Tree])(classesToRemove: List[Name] = defaultClasses)(traitsToRemove: List[Name]) = { def removeDefaultTraitsFromList(trees: List[Tree], traitsToRemove: List[Name]): List[Tree] = @@ -623,9 +631,10 @@ trait Printers extends api.Printers { self: SymbolTable => removeDefaultTraitsFromList(removeDefaultClassesFromList(trees, classesToRemove), traitsToRemove) } - protected def removeDefaultClassesFromList(trees: List[Tree], classesToRemove: List[Name] = defaultClasses) = + protected def removeDefaultClassesFromList(trees: List[Tree], classesToRemove: List[Name] = defaultClasses) = originalTypeTrees(trees) filter { case Select(Ident(sc), name) => !(classesToRemove.contains(name) && sc == nme.scala_) + case tt: TypeTree if tt.tpe != null => !(classesToRemove contains(newTypeName(tt.tpe.toString()))) case _ => true } @@ -637,7 +646,7 @@ trait Printers extends api.Printers { self: SymbolTable => } override def printOpt(prefix: String, tree: Tree) = - if (!emptyTree(tree)) super.printOpt(prefix, tree) + if (!isEmptyTree(tree)) super.printOpt(prefix, tree) override def printColumn(ts: List[Tree], start: String, sep: String, end: String) = { super.printColumn(ts.filter(!syntheticToRemove(_)), start, sep, end) @@ -952,7 +961,7 @@ trait Printers extends api.Printers { self: SymbolTable => def printTp = print("(", tp, ")") tp match { - case EmptyTree | build.SyntacticEmptyTypeTree() => printTp + case EmptyTree | EmptyTypeTree() => printTp // case for untypechecked trees case Annotated(annot, arg) if (expr ne null) && (arg ne null) && expr.equalsStructure(arg) => printTp // remove double arg - 5: 5: @unchecked case tt: TypeTree if tt.original.isInstanceOf[Annotated] => printTp @@ -963,7 +972,7 @@ trait Printers extends api.Printers { self: SymbolTable => // print only fun when targs are TypeTrees with empty original case TypeApply(fun, targs) => - if (targs.exists(emptyTree(_))) { + if (targs.exists(isEmptyTree(_))) { print(fun) } else super.printTree(tree) @@ -984,8 +993,8 @@ trait Printers extends api.Printers { self: SymbolTable => case treeInfo.Unapplied(body) => body match { case Select(qual, name) if name == nme.unapply => print(qual) - case TypeApply(Select(qual, name), args) if name == nme.unapply || name == nme.unapplySeq => - print(TypeApply(qual, args)) + case TypeApply(Select(qual, name), _) if name == nme.unapply || name == nme.unapplySeq => + print(qual) case _ => print(body) } case _ => print(fun) @@ -1061,7 +1070,11 @@ trait Printers extends api.Printers { self: SymbolTable => print("(", qualifier, ")#", blankForOperatorName(selector), printedName(selector)) case tt: TypeTree => - if (!emptyTree(tt)) print(tt.original) + if (!isEmptyTree(tt)) { + val original = tt.original + if (original != null) print(original) + else super.printTree(tree) + } case AppliedTypeTree(tp, args) => // it's possible to have (=> String) => String type but Function1[=> String, String] is not correct diff --git a/test/junit/scala/reflect/internal/PrintersTest.scala b/test/junit/scala/reflect/internal/PrintersTest.scala index 4587417a99ce..1458b942dca5 100644 --- a/test/junit/scala/reflect/internal/PrintersTest.scala +++ b/test/junit/scala/reflect/internal/PrintersTest.scala @@ -33,10 +33,10 @@ object PrinterHelper { def wrapCode(source: String) = { val context = sm""" |trait PrintersContext { - | class baz extends scala.annotation.StaticAnnotation; - | class foo1[A, B] extends scala.annotation.StaticAnnotation; - | class foo2[A, B](a: scala.Int)(b: scala.Int) extends scala.annotation.StaticAnnotation; - | class foo3[Af, Bf](a: scala.Int)(b: scala.Float, c: PrintersContext.this.foo1[Af, Bf]) extends scala.annotation.StaticAnnotation; + | class baz extends scala.annotation.Annotation with scala.annotation.StaticAnnotation; + | class foo1[A, B] extends scala.annotation.Annotation with scala.annotation.StaticAnnotation; + | class foo2[A, B](a: scala.Int)(b: scala.Int) extends scala.annotation.Annotation with scala.annotation.StaticAnnotation; + | class foo3[Af, Bf](a: scala.Int)(b: scala.Float, c: PrintersContext.this.foo1[Af, Bf]) extends scala.annotation.Annotation with scala.annotation.StaticAnnotation; | trait A1; | trait B1; |${source.trim.lines map {" " + _} mkString s"$LF"} @@ -54,8 +54,12 @@ object PrinterHelper { } } - def assertTreeCode(tree: Tree)(code: String) = { - assertEquals("using quasiquote or given tree"+LF, code.trim, normalizeEOL(showCode(tree))) + def assertTreeCode(tree: Tree, typecheck: Boolean = false)(code: String) = { + if (typecheck) { + assertEquals("using quasiquote or given tree (typechecked)"+LF, code.trim, normalizeEOL(showCode(toolbox.typecheck(tree)))) + } else { + assertEquals("using quasiquote or given tree"+LF, code.trim, normalizeEOL(showCode(tree))) + } } def assertPrintedCode(source: String, checkTypedTree: Boolean = true, wrapCode: Boolean = false) = { @@ -312,17 +316,17 @@ trait BasePrintTests { @Test def testFunc1 = assertResultCode( code = "List(1, 2, 3).map((i: Int) => i - 1)")( parsedCode = "List(1, 2, 3).map(((i: Int) => i.-(1)))", - typedCode = sm"scala.collection.immutable.List.apply(1, 2, 3).map(((i: scala.Int) => i.-(1)))(scala.collection.immutable.List.canBuildFrom)") + typedCode = sm"scala.collection.immutable.List.apply[Int](1, 2, 3).map[Int, List[Int]](((i: scala.Int) => i.-(1)))(scala.collection.immutable.List.canBuildFrom[Int])") @Test def testFunc2 = assertResultCode( code = "val sum: Seq[Int] => Int = _ reduceLeft (_+_)")( parsedCode = "val sum: _root_.scala.Function1[Seq[Int], Int] = ((x$1) => x$1.reduceLeft(((x$2, x$3) => x$2.+(x$3))))", - typedCode = "val sum: _root_.scala.Function1[scala.`package`.Seq[scala.Int], scala.Int] = ((x$1) => x$1.reduceLeft(((x$2, x$3) => x$2.+(x$3))))") + typedCode = "val sum: _root_.scala.Function1[scala.`package`.Seq[scala.Int], scala.Int] = ((x$1: Seq[Int]) => x$1.reduceLeft[Int](((x$2: Int, x$3: Int) => x$2.+(x$3))))") @Test def testFunc3 = assertResultCode( code = "List(1, 2, 3) map (_ - 1)")( parsedCode = "List(1, 2, 3).map(((x$1) => x$1.-(1))) ", - typedCode = "scala.collection.immutable.List.apply(1, 2, 3).map(((x$1) => x$1.-(1)))(scala.collection.immutable.List.canBuildFrom)") + typedCode = "scala.collection.immutable.List.apply[Int](1, 2, 3).map[Int, List[Int]](((x$1: Int) => x$1.-(1)))(scala.collection.immutable.List.canBuildFrom[Int])") @Test def testFunc4 = assertResultCode( code = "val x: String => Int = ((str: String) => 1)")( @@ -401,7 +405,8 @@ trait ClassPrintTests { @Test def testClassWithImplicitParams = assertPrintedCode("class X(var i: scala.Int)(implicit val d: scala.Double, var f: scala.Float)") - @Test def testClassWithEarly = assertPrintedCode(sm""" + @Test def testClassWithEarly = + assertPrintedCode(sm""" |class X(var i: scala.Int) extends { | val a = i; | type B @@ -419,15 +424,22 @@ trait ClassPrintTests { | throw Throw2.this.e |}""") - /* - class Test { - val (a, b) = (1, 2) - } - */ - @Test def testClassWithAssignmentWithTuple1 = assertPrintedCode(sm""" + @Test def testClassWithAssignmentWithTuple1 = assertResultCode(sm""" |class Test { - | private[this] val x$$1 = (scala.Tuple2.apply(1, 2): @scala.unchecked) match { - | case scala.Tuple2((a @ _), (b @ _)) => scala.Tuple2.apply(a, b) + | val (a, b) = (1, 2) + |}""")( + parsedCode = sm""" + |class Test { + | private[this] val x$$1 = (scala.Tuple2(1, 2): @scala.unchecked) match { + | case scala.Tuple2((a @ _), (b @ _)) => scala.Tuple2(a, b) + | }; + | val a = x$$1._1; + | val b = x$$1._2 + |}""", + typedCode = sm""" + |class Test { + | private[this] val x$$1 = (scala.Tuple2.apply[Int, Int](1, 2): @scala.unchecked) match { + | case scala.Tuple2((a @ _), (b @ _)) => scala.Tuple2.apply[Int, Int](a, b) | }; | val a = Test.this.x$$1._1; | val b = Test.this.x$$1._2 @@ -448,8 +460,8 @@ trait ClassPrintTests { |}""", typedCode = sm""" |class Test { - | private[this] val x$$1 = (scala.Predef.ArrowAssoc(1).->(2): @scala.unchecked) match { - | case scala.Tuple2((a @ _), (b @ _)) => scala.Tuple2.apply(a, b) + | private[this] val x$$1 = (scala.Predef.ArrowAssoc[Int](1).->[Int](2): @scala.unchecked) match { + | case scala.Tuple2((a @ _), (b @ _)) => scala.Tuple2.apply[Int, Int](a, b) | }; | val a = Test.this.x$$1._1; | val b = Test.this.x$$1._2 @@ -462,8 +474,8 @@ trait ClassPrintTests { */ @Test def testClassWithPatternMatchInAssignment = assertPrintedCode(sm""" |class Test { - | private[this] val x$$1 = (scala.collection.immutable.List.apply(1, 3, 5): @scala.unchecked) match { - | case scala.collection.immutable.List((one @ _), (three @ _), (five @ _)) => scala.Tuple3.apply(one, three, five) + | private[this] val x$$1 = (scala.collection.immutable.List.apply[scala.Int](1, 3, 5): @scala.unchecked) match { + | case scala.collection.immutable.List((one @ _), (three @ _), (five @ _)) => scala.Tuple3.apply[scala.Int, scala.Int, scala.Int](one, three, five) | }; | val one = Test.this.x$$1._1; | val three = Test.this.x$$1._2; @@ -626,7 +638,7 @@ trait ClassPrintTests { @Test def testObjectWithPatternMatch1 = assertPrintedCode(sm""" |object PM1 { - | scala.collection.immutable.List.apply(1, 2) match { + | scala.collection.immutable.List.apply[scala.Int](1, 2) match { | case (i @ _) => i | } |}""") @@ -715,7 +727,7 @@ trait ClassPrintTests { |}""", typedCode = sm""" |object PM5 { - | scala.collection.immutable.List.apply(1, 2) match { + | scala.collection.immutable.List.apply[Int](1, 2) match { | case scala.`package`.::((x @ _), (xs @ _)) => x | } |}""") @@ -756,7 +768,7 @@ trait ClassPrintTests { @Test def testObjectWithPatternMatch8 = assertPrintedCode(sm""" |{ | object Extractor { - | def unapply(i: scala.Int) = scala.Some.apply(i) + | def unapply(i: scala.Int) = scala.Some.apply[scala.Int](i) | }; | object PM9 { | 42 match { @@ -991,7 +1003,7 @@ trait ValAndDefPrintTests { @Test def testDefWithLazyVal2 = assertPrintedCode(sm""" |def a = { - | lazy val test = { + | lazy val test: Unit = { | scala.Predef.println(); | scala.Predef.println() | }; @@ -1161,4 +1173,17 @@ trait QuasiTreesPrintTests { |case class X(x: Int, s: String) { | def y = "test" |}""") + + @Test def testQuasiCaseClassWithTypes1 = assertTreeCode(q"""case class X(x: ${typeOf[Int]}, s: ${typeOf[String]}){ def y = "test" }""")(sm""" + |case class X(x: Int, s: String) { + | def y = "test" + |}""") + + @Test def testQuasiCaseClassWithTypes2 = assertTreeCode(q"""case class X(x: ${typeOf[Int]}, s: ${typeOf[String]}){ def y = "test" }""", typecheck = true)(sm""" + |{ + | case class X(x: Int, s: String) { + | def y = "test" + | }; + | () + |}""") } \ No newline at end of file From f0c33206bc125cf4326a340e2cd7c7ec2f360726 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Fri, 9 May 2014 16:47:56 +0200 Subject: [PATCH 236/826] SI-8570 set the checkinit bit for unit-typed fields of traits Fix only, refactoring in subsequent commit. --- src/compiler/scala/tools/nsc/transform/Mixin.scala | 9 ++++++--- test/files/run/t8570.flags | 1 + test/files/run/t8570.scala | 10 ++++++++++ test/files/run/t8570a.check | 1 + test/files/run/t8570a.flags | 1 + test/files/run/t8570a.scala | 14 ++++++++++++++ 6 files changed, 33 insertions(+), 3 deletions(-) create mode 100644 test/files/run/t8570.flags create mode 100644 test/files/run/t8570.scala create mode 100644 test/files/run/t8570a.check create mode 100644 test/files/run/t8570a.flags create mode 100644 test/files/run/t8570a.scala diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala index 673bc04bd947..9c9008bfcc8b 100644 --- a/src/compiler/scala/tools/nsc/transform/Mixin.scala +++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala @@ -1042,15 +1042,18 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { // add accessor definitions addDefDef(sym, { if (sym.isSetter) { + val getter = sym.getter(clazz) + def setInitFlag = mkSetFlag(clazz, fieldOffset(getter), getter, bitmapKind(getter)) if (isOverriddenSetter(sym)) UNIT else accessedRef match { - case ref @ Literal(_) => ref + case ref @ Literal(_) => + if (!needsInitFlag(getter)) ref + else Block(setInitFlag, ref) case ref => val init = Assign(ref, Ident(sym.firstParam)) - val getter = sym.getter(clazz) if (!needsInitFlag(getter)) init - else Block(init, mkSetFlag(clazz, fieldOffset(getter), getter, bitmapKind(getter)), UNIT) + else Block(init, setInitFlag, UNIT) } } else if (needsInitFlag(sym)) diff --git a/test/files/run/t8570.flags b/test/files/run/t8570.flags new file mode 100644 index 000000000000..3d1ee4760af6 --- /dev/null +++ b/test/files/run/t8570.flags @@ -0,0 +1 @@ +-Xcheckinit diff --git a/test/files/run/t8570.scala b/test/files/run/t8570.scala new file mode 100644 index 000000000000..bbe83e908044 --- /dev/null +++ b/test/files/run/t8570.scala @@ -0,0 +1,10 @@ +trait Trait40_1 { + val value37_2 = () + def run = { value37_2 } +} + +object Test { + def main(args: Array[String]) { + (new Trait40_1 {}).run + } +} diff --git a/test/files/run/t8570a.check b/test/files/run/t8570a.check new file mode 100644 index 000000000000..6a452c185a8c --- /dev/null +++ b/test/files/run/t8570a.check @@ -0,0 +1 @@ +() diff --git a/test/files/run/t8570a.flags b/test/files/run/t8570a.flags new file mode 100644 index 000000000000..3d1ee4760af6 --- /dev/null +++ b/test/files/run/t8570a.flags @@ -0,0 +1 @@ +-Xcheckinit diff --git a/test/files/run/t8570a.scala b/test/files/run/t8570a.scala new file mode 100644 index 000000000000..ef116e2a8a93 --- /dev/null +++ b/test/files/run/t8570a.scala @@ -0,0 +1,14 @@ +trait Trait40_1 { + val value37_2 = () + def run = { value37_2 } +} + +trait T1 extends Trait40_1 { + override val value37_2 = () +} + +object Test { + def main(args: Array[String]) { + println((new T1 {}).run) + } +} From 63321ac39651fd8493a821e3da5cea36d7ce2b3c Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Fri, 9 May 2014 11:31:21 +0200 Subject: [PATCH 237/826] Clarify and clean up trait getter / setter generation --- .../scala/tools/nsc/transform/Mixin.scala | 89 +++++++++++-------- 1 file changed, 54 insertions(+), 35 deletions(-) diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala index 9c9008bfcc8b..33e8e47c765d 100644 --- a/src/compiler/scala/tools/nsc/transform/Mixin.scala +++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala @@ -1004,24 +1004,56 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { buildBitmapOffsets() var stats1 = addCheckedGetters(clazz, stats) - def accessedReference(sym: Symbol) = sym.tpe match { - case MethodType(Nil, ConstantType(c)) => Literal(c) - case _ => - // if it is a mixed-in lazy value, complete the accessor - if (sym.isLazy && sym.isGetter) { - val isUnit = sym.tpe.resultType.typeSymbol == UnitClass - val initCall = Apply(staticRef(initializer(sym)), gen.mkAttributedThis(clazz) :: Nil) - val selection = Select(This(clazz), sym.accessed) - val init = if (isUnit) initCall else atPos(sym.pos)(Assign(selection, initCall)) - val returns = if (isUnit) UNIT else selection - - mkLazyDef(clazz, sym, List(init), returns, fieldOffset(sym)) - } - else sym.getter(sym.owner).tpe.resultType.typeSymbol match { - case UnitClass => UNIT - case _ => Select(This(clazz), sym.accessed) - } + def getterBody(getter: Symbol) = { + assert(getter.isGetter) + val readValue = getter.tpe match { + // A field "final val f = const" in a trait generates a getter with a ConstantType. + case MethodType(Nil, ConstantType(c)) => + Literal(c) + case _ => + // if it is a mixed-in lazy value, complete the accessor + if (getter.isLazy) { + val isUnit = isUnitGetter(getter) + val initCall = Apply(staticRef(initializer(getter)), gen.mkAttributedThis(clazz) :: Nil) + val selection = fieldAccess(getter) + val init = if (isUnit) initCall else atPos(getter.pos)(Assign(selection, initCall)) + val returns = if (isUnit) UNIT else selection + mkLazyDef(clazz, getter, List(init), returns, fieldOffset(getter)) + } + // For a field of type Unit in a trait, no actual field is generated when being mixed in. + else if (isUnitGetter(getter)) UNIT + else fieldAccess(getter) + } + if (!needsInitFlag(getter)) readValue + else mkCheckedAccessor(clazz, readValue, fieldOffset(getter), getter.pos, getter) + } + + def setterBody(setter: Symbol) = { + val getter = setter.getterIn(clazz) + + // A trait with a field of type Unit creates a trait setter (invoked by the + // implementation class constructor), like for any other trait field. + // However, no actual field is created in the class that mixes in the trait. + // Therefore the setter does nothing (except setting the -Xcheckinit flag). + + val setInitFlag = + if (!needsInitFlag(getter)) Nil + else List(mkSetFlag(clazz, fieldOffset(getter), getter, bitmapKind(getter))) + + val fieldInitializer = + if (isUnitGetter(getter)) Nil + else List(Assign(fieldAccess(setter), Ident(setter.firstParam))) + + (fieldInitializer ::: setInitFlag) match { + case Nil => UNIT + // If there's only one statement, the Block factory does not actually create a Block. + case stats => Block(stats: _*) + } } + + def isUnitGetter(getter: Symbol) = getter.tpe.resultType.typeSymbol == UnitClass + def fieldAccess(accessor: Symbol) = Select(This(clazz), accessor.accessed) + def isOverriddenSetter(sym: Symbol) = nme.isTraitSetterName(sym.name) && { val other = sym.nextOverriddenSymbol @@ -1036,30 +1068,17 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { } // if class is not a trait add accessor definitions else if (!clazz.isTrait) { - // This needs to be a def to avoid sharing trees - def accessedRef = accessedReference(sym) if (isConcreteAccessor(sym)) { // add accessor definitions addDefDef(sym, { if (sym.isSetter) { - val getter = sym.getter(clazz) - def setInitFlag = mkSetFlag(clazz, fieldOffset(getter), getter, bitmapKind(getter)) + // If this is a setter of a mixed-in field which is overridden by another mixin, + // the trait setter of the overridden one does not need to do anything - the + // trait setter of the overriding field will initialize the field. if (isOverriddenSetter(sym)) UNIT - else accessedRef match { - case ref @ Literal(_) => - if (!needsInitFlag(getter)) ref - else Block(setInitFlag, ref) - case ref => - val init = Assign(ref, Ident(sym.firstParam)) - - if (!needsInitFlag(getter)) init - else Block(init, setInitFlag, UNIT) - } + else setterBody(sym) } - else if (needsInitFlag(sym)) - mkCheckedAccessor(clazz, accessedRef, fieldOffset(sym), sym.pos, sym) - else - accessedRef + else getterBody(sym) }) } else if (sym.isModule && !(sym hasFlag LIFTED | BRIDGE)) { From f0846e74dbce99ae1d8e2f1d7e5faeadc2a5c375 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Fri, 9 May 2014 11:40:04 +0200 Subject: [PATCH 238/826] Disable run/t7974 under checkinit --- test/files/run/t7974.flags | 1 + test/files/run/t7974/Test.scala | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) create mode 100644 test/files/run/t7974.flags diff --git a/test/files/run/t7974.flags b/test/files/run/t7974.flags new file mode 100644 index 000000000000..5fc2a0389474 --- /dev/null +++ b/test/files/run/t7974.flags @@ -0,0 +1 @@ +-Xcheckinit:false diff --git a/test/files/run/t7974/Test.scala b/test/files/run/t7974/Test.scala index 9403ea332bfd..433d9061a747 100644 --- a/test/files/run/t7974/Test.scala +++ b/test/files/run/t7974/Test.scala @@ -9,7 +9,7 @@ object Test extends BytecodeTest { val classNode = loadClassNode("Symbols", skipDebugInfo = false) val textifier = new Textifier classNode.accept(new TraceClassVisitor(null, textifier, null)) - + val classString = stringFromWriter(w => textifier.print(w)) val result = classString.split('\n') From bed189ec8c373dfd429d424256dfbfcc17ac4221 Mon Sep 17 00:00:00 2001 From: Todd Vierling Date: Fri, 9 May 2014 13:09:49 -0400 Subject: [PATCH 239/826] @inline Predef.identity[A]. Since identity[A] is often used as a function directly supplied to methods requiring (A)=>A, there's no need to have the generated Function1 object contain an explicit call to identity[A](). This implementation isn't going to change, so let the synthetic Function1 elide the extra call, generating just "aload_1; areturn". --- src/library/scala/Predef.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala index faeb1dcbe2bc..2be6a9dcc1cd 100644 --- a/src/library/scala/Predef.scala +++ b/src/library/scala/Predef.scala @@ -126,7 +126,7 @@ object Predef extends LowPriorityImplicits with DeprecatedPredef { def optManifest[T](implicit m: OptManifest[T]) = m // Minor variations on identity functions - def identity[A](x: A): A = x // @see `conforms` for the implicit version + @inline def identity[A](x: A): A = x // @see `conforms` for the implicit version @inline def implicitly[T](implicit e: T) = e // for summoning implicit values from the nether world -- TODO: when dependent method types are on by default, give this result type `e.type`, so that inliner has better chance of knowing which method to inline in calls like `implicitly[MatchingStrategy[Option]].zero` @inline def locally[T](x: T): T = x // to communicate intent and avoid unmoored statements From bce6bf3a715315ab99c889256bab1d637b8c73cc Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sat, 10 May 2014 12:03:56 +0200 Subject: [PATCH 240/826] SI-8576 Temporarily disable part of serialization test Parts of this test fail if testing a library built with -Xcheckinit. The failures seem to be in two categories: - A component of the serialized structure does not have a declared SerialVersionUID, meaning that the extra field added to track initialization results in a different ID. This manifests as a `java.io.InvalidClassException` when deserializing the blobs of data saved in the test case. - Spurious `UnitializedFieldErrors` when calling methods on the object that has been serialized and then deserialized. Until we figure out the right course of action (more @SerialVersionUID annotations / weaker tests / ...), this commit disabled those tests. --- test/files/run/t8549.scala | 57 +++++++++++++++++++++++--------------- 1 file changed, 34 insertions(+), 23 deletions(-) diff --git a/test/files/run/t8549.scala b/test/files/run/t8549.scala index 1b402d2d22e0..d3355208fa01 100644 --- a/test/files/run/t8549.scala +++ b/test/files/run/t8549.scala @@ -85,13 +85,9 @@ object Test extends App { check(List(1, 2, 3))( "rO0ABXNyADJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAABAwAAeHBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJzcQB+AAIAAAADc3IALHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3RTZXJpYWxpemVFbmQkilxjW/dTC20CAAB4cHg=") check(Nil)( "rO0ABXNyADJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAABAwAAeHBzcgAsc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuTGlzdFNlcmlhbGl6ZUVuZCSKXGNb91MLbQIAAHhweA==") - check(Vector(1))( "rO0ABXNyACFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5WZWN0b3Lkd3dcHq6PXAIAC0kABWRlcHRoWgAFZGlydHlJAAhlbmRJbmRleEkABWZvY3VzSQAKc3RhcnRJbmRleFsACGRpc3BsYXkwdAATW0xqYXZhL2xhbmcvT2JqZWN0O1sACGRpc3BsYXkxcQB+AAFbAAhkaXNwbGF5MnEAfgABWwAIZGlzcGxheTNxAH4AAVsACGRpc3BsYXk0cQB+AAFbAAhkaXNwbGF5NXEAfgABeHAAAAABAAAAAAEAAAAAAAAAAHVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAACBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcA==") - check(Vector())( "rO0ABXNyACFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5WZWN0b3Lkd3dcHq6PXAIAC0kABWRlcHRoWgAFZGlydHlJAAhlbmRJbmRleEkABWZvY3VzSQAKc3RhcnRJbmRleFsACGRpc3BsYXkwdAATW0xqYXZhL2xhbmcvT2JqZWN0O1sACGRpc3BsYXkxcQB+AAFbAAhkaXNwbGF5MnEAfgABWwAIZGlzcGxheTNxAH4AAVsACGRpc3BsYXk0cQB+AAFbAAhkaXNwbGF5NXEAfgABeHAAAAAAAAAAAAAAAAAAAAAAAHBwcHBwcA==") - - object Enum extends Enumeration { - val V1 = new Value { def id = 42 } - val V2 = new Val(42) - } + // TODO SI-8576 unstable under -Xcheckinit + // check(Vector(1))( "rO0ABXNyACFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5WZWN0b3Lkd3dcHq6PXAIAC0kABWRlcHRoWgAFZGlydHlJAAhlbmRJbmRleEkABWZvY3VzSQAKc3RhcnRJbmRleFsACGRpc3BsYXkwdAATW0xqYXZhL2xhbmcvT2JqZWN0O1sACGRpc3BsYXkxcQB+AAFbAAhkaXNwbGF5MnEAfgABWwAIZGlzcGxheTNxAH4AAVsACGRpc3BsYXk0cQB+AAFbAAhkaXNwbGF5NXEAfgABeHAAAAABAAAAAAEAAAAAAAAAAHVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAACBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcA==") + // check(Vector())( "rO0ABXNyACFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5WZWN0b3Lkd3dcHq6PXAIAC0kABWRlcHRoWgAFZGlydHlJAAhlbmRJbmRleEkABWZvY3VzSQAKc3RhcnRJbmRleFsACGRpc3BsYXkwdAATW0xqYXZhL2xhbmcvT2JqZWN0O1sACGRpc3BsYXkxcQB+AAFbAAhkaXNwbGF5MnEAfgABWwAIZGlzcGxheTNxAH4AAVsACGRpc3BsYXk0cQB+AAFbAAhkaXNwbGF5NXEAfgABeHAAAAAAAAAAAAAAAAAAAAAAAHBwcHBwcA==") import collection.{ mutable, immutable } @@ -101,16 +97,20 @@ object Test extends App { check(reflect.classTag[String])("rO0ABXNyAB5zY2FsYS5yZWZsZWN0LkNsYXNzVGFnJCRhbm9uJDG7ePPrmQBkhgIAAUwAD3J1bnRpbWVDbGFzczEkMXQAEUxqYXZhL2xhbmcvQ2xhc3M7eHB2cgAQamF2YS5sYW5nLlN0cmluZ6DwpDh6O7NCAgAAeHA=") check(reflect.classTag[Object])("rO0ABXNyACVzY2FsYS5yZWZsZWN0Lk1hbmlmZXN0RmFjdG9yeSQkYW5vbiQymPrtq/Ci1gsCAAB4cgAtc2NhbGEucmVmbGVjdC5NYW5pZmVzdEZhY3RvcnkkUGhhbnRvbU1hbmlmZXN0rzigP7KRh/kCAAFMAAh0b1N0cmluZ3QAEkxqYXZhL2xhbmcvU3RyaW5nO3hyAC9zY2FsYS5yZWZsZWN0Lk1hbmlmZXN0RmFjdG9yeSRDbGFzc1R5cGVNYW5pZmVzdFq6NWvfTgYFAgADTAAGcHJlZml4dAAOTHNjYWxhL09wdGlvbjtMAAxydW50aW1lQ2xhc3N0ABFMamF2YS9sYW5nL0NsYXNzO0wADXR5cGVBcmd1bWVudHN0ACFMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvTGlzdDt4cHNyAAtzY2FsYS5Ob25lJEZQJPZTypSsAgAAeHIADHNjYWxhLk9wdGlvbv5pN/3bDmZ0AgAAeHB2cgAQamF2YS5sYW5nLk9iamVjdAAAAAAAAAAAAAAAeHBzcgAyc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuTGlzdCRTZXJpYWxpemF0aW9uUHJveHkAAAAAAAAAAQMAAHhwc3IALHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3RTZXJpYWxpemVFbmQkilxjW/dTC20CAAB4cHh0AAZPYmplY3Q=") - check(Enum)( "rO0ABXNyAApUZXN0JEVudW0ketCIyQ8C23MCAAJMAAJWMXQAGUxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZTtMAAJWMnQAF0xzY2FsYS9FbnVtZXJhdGlvbiRWYWw7eHIAEXNjYWxhLkVudW1lcmF0aW9udaDN3ZgOWY4CAAhJAAZuZXh0SWRJABtzY2FsYSRFbnVtZXJhdGlvbiQkYm90dG9tSWRJABhzY2FsYSRFbnVtZXJhdGlvbiQkdG9wSWRMABRWYWx1ZU9yZGVyaW5nJG1vZHVsZXQAIkxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZU9yZGVyaW5nJDtMAA9WYWx1ZVNldCRtb2R1bGV0AB1Mc2NhbGEvRW51bWVyYXRpb24kVmFsdWVTZXQkO0wACG5leHROYW1ldAAbTHNjYWxhL2NvbGxlY3Rpb24vSXRlcmF0b3I7TAAXc2NhbGEkRW51bWVyYXRpb24kJG5tYXB0AB5Mc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL01hcDtMABdzY2FsYSRFbnVtZXJhdGlvbiQkdm1hcHEAfgAHeHAAAAArAAAAAAAAACtwcHBzcgAgc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLkhhc2hNYXAAAAAAAAAAAQMAAHhwdw0AAALuAAAAAAAAAAQAeHNxAH4ACXcNAAAC7gAAAAEAAAAEAHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAAqc3IAFXNjYWxhLkVudW1lcmF0aW9uJFZhbM9pZ6/J/O1PAgACSQAYc2NhbGEkRW51bWVyYXRpb24kVmFsJCRpTAAEbmFtZXQAEkxqYXZhL2xhbmcvU3RyaW5nO3hyABdzY2FsYS5FbnVtZXJhdGlvbiRWYWx1ZWJpfC/tIR1RAgACTAAGJG91dGVydAATTHNjYWxhL0VudW1lcmF0aW9uO0wAHHNjYWxhJEVudW1lcmF0aW9uJCRvdXRlckVudW1xAH4AEnhwcQB+AAhxAH4ACAAAACpweHNyABFUZXN0JEVudW0kJGFub24kMVlIjlmE1sXaAgAAeHEAfgARcQB+AAhxAH4ACHEAfgAT") - check(Enum.V1)( "rO0ABXNyABFUZXN0JEVudW0kJGFub24kMVlIjlmE1sXaAgAAeHIAF3NjYWxhLkVudW1lcmF0aW9uJFZhbHVlYml8L+0hHVECAAJMAAYkb3V0ZXJ0ABNMc2NhbGEvRW51bWVyYXRpb247TAAcc2NhbGEkRW51bWVyYXRpb24kJG91dGVyRW51bXEAfgACeHBzcgAKVGVzdCRFbnVtJHrQiMkPAttzAgACTAACVjF0ABlMc2NhbGEvRW51bWVyYXRpb24kVmFsdWU7TAACVjJ0ABdMc2NhbGEvRW51bWVyYXRpb24kVmFsO3hyABFzY2FsYS5FbnVtZXJhdGlvbnWgzd2YDlmOAgAISQAGbmV4dElkSQAbc2NhbGEkRW51bWVyYXRpb24kJGJvdHRvbUlkSQAYc2NhbGEkRW51bWVyYXRpb24kJHRvcElkTAAUVmFsdWVPcmRlcmluZyRtb2R1bGV0ACJMc2NhbGEvRW51bWVyYXRpb24kVmFsdWVPcmRlcmluZyQ7TAAPVmFsdWVTZXQkbW9kdWxldAAdTHNjYWxhL0VudW1lcmF0aW9uJFZhbHVlU2V0JDtMAAhuZXh0TmFtZXQAG0xzY2FsYS9jb2xsZWN0aW9uL0l0ZXJhdG9yO0wAF3NjYWxhJEVudW1lcmF0aW9uJCRubWFwdAAeTHNjYWxhL2NvbGxlY3Rpb24vbXV0YWJsZS9NYXA7TAAXc2NhbGEkRW51bWVyYXRpb24kJHZtYXBxAH4AC3hwAAAAKwAAAAAAAAArcHBwc3IAIHNjYWxhLmNvbGxlY3Rpb24ubXV0YWJsZS5IYXNoTWFwAAAAAAAAAAEDAAB4cHcNAAAC7gAAAAAAAAAEAHhzcQB+AA13DQAAAu4AAAABAAAABABzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAKnNyABVzY2FsYS5FbnVtZXJhdGlvbiRWYWzPaWevyfztTwIAAkkAGHNjYWxhJEVudW1lcmF0aW9uJFZhbCQkaUwABG5hbWV0ABJMamF2YS9sYW5nL1N0cmluZzt4cQB+AAFxAH4ADHEAfgAMAAAAKnB4cQB+AANxAH4AFXEAfgAM") - check(Enum.V2)( "rO0ABXNyABVzY2FsYS5FbnVtZXJhdGlvbiRWYWzPaWevyfztTwIAAkkAGHNjYWxhJEVudW1lcmF0aW9uJFZhbCQkaUwABG5hbWV0ABJMamF2YS9sYW5nL1N0cmluZzt4cgAXc2NhbGEuRW51bWVyYXRpb24kVmFsdWViaXwv7SEdUQIAAkwABiRvdXRlcnQAE0xzY2FsYS9FbnVtZXJhdGlvbjtMABxzY2FsYSRFbnVtZXJhdGlvbiQkb3V0ZXJFbnVtcQB+AAN4cHNyAApUZXN0JEVudW0ketCIyQ8C23MCAAJMAAJWMXQAGUxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZTtMAAJWMnQAF0xzY2FsYS9FbnVtZXJhdGlvbiRWYWw7eHIAEXNjYWxhLkVudW1lcmF0aW9udaDN3ZgOWY4CAAhJAAZuZXh0SWRJABtzY2FsYSRFbnVtZXJhdGlvbiQkYm90dG9tSWRJABhzY2FsYSRFbnVtZXJhdGlvbiQkdG9wSWRMABRWYWx1ZU9yZGVyaW5nJG1vZHVsZXQAIkxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZU9yZGVyaW5nJDtMAA9WYWx1ZVNldCRtb2R1bGV0AB1Mc2NhbGEvRW51bWVyYXRpb24kVmFsdWVTZXQkO0wACG5leHROYW1ldAAbTHNjYWxhL2NvbGxlY3Rpb24vSXRlcmF0b3I7TAAXc2NhbGEkRW51bWVyYXRpb24kJG5tYXB0AB5Mc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL01hcDtMABdzY2FsYSRFbnVtZXJhdGlvbiQkdm1hcHEAfgAMeHAAAAArAAAAAAAAACtwcHBzcgAgc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLkhhc2hNYXAAAAAAAAAAAQMAAHhwdw0AAALuAAAAAAAAAAQAeHNxAH4ADncNAAAC7gAAAAEAAAAEAHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAAqcQB+AAR4c3IAEVRlc3QkRW51bSQkYW5vbiQxWUiOWYTWxdoCAAB4cQB+AAJxAH4ADXEAfgANcQB+AARxAH4ADQAAACpw") + // TODO SI-8576 unstable under -Xcheckinit + // check(Enum)( "rO0ABXNyAApUZXN0JEVudW0ketCIyQ8C23MCAAJMAAJWMXQAGUxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZTtMAAJWMnQAF0xzY2FsYS9FbnVtZXJhdGlvbiRWYWw7eHIAEXNjYWxhLkVudW1lcmF0aW9udaDN3ZgOWY4CAAhJAAZuZXh0SWRJABtzY2FsYSRFbnVtZXJhdGlvbiQkYm90dG9tSWRJABhzY2FsYSRFbnVtZXJhdGlvbiQkdG9wSWRMABRWYWx1ZU9yZGVyaW5nJG1vZHVsZXQAIkxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZU9yZGVyaW5nJDtMAA9WYWx1ZVNldCRtb2R1bGV0AB1Mc2NhbGEvRW51bWVyYXRpb24kVmFsdWVTZXQkO0wACG5leHROYW1ldAAbTHNjYWxhL2NvbGxlY3Rpb24vSXRlcmF0b3I7TAAXc2NhbGEkRW51bWVyYXRpb24kJG5tYXB0AB5Mc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL01hcDtMABdzY2FsYSRFbnVtZXJhdGlvbiQkdm1hcHEAfgAHeHAAAAArAAAAAAAAACtwcHBzcgAgc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLkhhc2hNYXAAAAAAAAAAAQMAAHhwdw0AAALuAAAAAAAAAAQAeHNxAH4ACXcNAAAC7gAAAAEAAAAEAHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAAqc3IAFXNjYWxhLkVudW1lcmF0aW9uJFZhbM9pZ6/J/O1PAgACSQAYc2NhbGEkRW51bWVyYXRpb24kVmFsJCRpTAAEbmFtZXQAEkxqYXZhL2xhbmcvU3RyaW5nO3hyABdzY2FsYS5FbnVtZXJhdGlvbiRWYWx1ZWJpfC/tIR1RAgACTAAGJG91dGVydAATTHNjYWxhL0VudW1lcmF0aW9uO0wAHHNjYWxhJEVudW1lcmF0aW9uJCRvdXRlckVudW1xAH4AEnhwcQB+AAhxAH4ACAAAACpweHNyABFUZXN0JEVudW0kJGFub24kMVlIjlmE1sXaAgAAeHEAfgARcQB+AAhxAH4ACHEAfgAT") + // check(Enum.V1)( "rO0ABXNyABFUZXN0JEVudW0kJGFub24kMVlIjlmE1sXaAgAAeHIAF3NjYWxhLkVudW1lcmF0aW9uJFZhbHVlYml8L+0hHVECAAJMAAYkb3V0ZXJ0ABNMc2NhbGEvRW51bWVyYXRpb247TAAcc2NhbGEkRW51bWVyYXRpb24kJG91dGVyRW51bXEAfgACeHBzcgAKVGVzdCRFbnVtJHrQiMkPAttzAgACTAACVjF0ABlMc2NhbGEvRW51bWVyYXRpb24kVmFsdWU7TAACVjJ0ABdMc2NhbGEvRW51bWVyYXRpb24kVmFsO3hyABFzY2FsYS5FbnVtZXJhdGlvbnWgzd2YDlmOAgAISQAGbmV4dElkSQAbc2NhbGEkRW51bWVyYXRpb24kJGJvdHRvbUlkSQAYc2NhbGEkRW51bWVyYXRpb24kJHRvcElkTAAUVmFsdWVPcmRlcmluZyRtb2R1bGV0ACJMc2NhbGEvRW51bWVyYXRpb24kVmFsdWVPcmRlcmluZyQ7TAAPVmFsdWVTZXQkbW9kdWxldAAdTHNjYWxhL0VudW1lcmF0aW9uJFZhbHVlU2V0JDtMAAhuZXh0TmFtZXQAG0xzY2FsYS9jb2xsZWN0aW9uL0l0ZXJhdG9yO0wAF3NjYWxhJEVudW1lcmF0aW9uJCRubWFwdAAeTHNjYWxhL2NvbGxlY3Rpb24vbXV0YWJsZS9NYXA7TAAXc2NhbGEkRW51bWVyYXRpb24kJHZtYXBxAH4AC3hwAAAAKwAAAAAAAAArcHBwc3IAIHNjYWxhLmNvbGxlY3Rpb24ubXV0YWJsZS5IYXNoTWFwAAAAAAAAAAEDAAB4cHcNAAAC7gAAAAAAAAAEAHhzcQB+AA13DQAAAu4AAAABAAAABABzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAKnNyABVzY2FsYS5FbnVtZXJhdGlvbiRWYWzPaWevyfztTwIAAkkAGHNjYWxhJEVudW1lcmF0aW9uJFZhbCQkaUwABG5hbWV0ABJMamF2YS9sYW5nL1N0cmluZzt4cQB+AAFxAH4ADHEAfgAMAAAAKnB4cQB+AANxAH4AFXEAfgAM") + // check(Enum.V2)( "rO0ABXNyABVzY2FsYS5FbnVtZXJhdGlvbiRWYWzPaWevyfztTwIAAkkAGHNjYWxhJEVudW1lcmF0aW9uJFZhbCQkaUwABG5hbWV0ABJMamF2YS9sYW5nL1N0cmluZzt4cgAXc2NhbGEuRW51bWVyYXRpb24kVmFsdWViaXwv7SEdUQIAAkwABiRvdXRlcnQAE0xzY2FsYS9FbnVtZXJhdGlvbjtMABxzY2FsYSRFbnVtZXJhdGlvbiQkb3V0ZXJFbnVtcQB+AAN4cHNyAApUZXN0JEVudW0ketCIyQ8C23MCAAJMAAJWMXQAGUxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZTtMAAJWMnQAF0xzY2FsYS9FbnVtZXJhdGlvbiRWYWw7eHIAEXNjYWxhLkVudW1lcmF0aW9udaDN3ZgOWY4CAAhJAAZuZXh0SWRJABtzY2FsYSRFbnVtZXJhdGlvbiQkYm90dG9tSWRJABhzY2FsYSRFbnVtZXJhdGlvbiQkdG9wSWRMABRWYWx1ZU9yZGVyaW5nJG1vZHVsZXQAIkxzY2FsYS9FbnVtZXJhdGlvbiRWYWx1ZU9yZGVyaW5nJDtMAA9WYWx1ZVNldCRtb2R1bGV0AB1Mc2NhbGEvRW51bWVyYXRpb24kVmFsdWVTZXQkO0wACG5leHROYW1ldAAbTHNjYWxhL2NvbGxlY3Rpb24vSXRlcmF0b3I7TAAXc2NhbGEkRW51bWVyYXRpb24kJG5tYXB0AB5Mc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL01hcDtMABdzY2FsYSRFbnVtZXJhdGlvbiQkdm1hcHEAfgAMeHAAAAArAAAAAAAAACtwcHBzcgAgc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLkhhc2hNYXAAAAAAAAAAAQMAAHhwdw0AAALuAAAAAAAAAAQAeHNxAH4ADncNAAAC7gAAAAEAAAAEAHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAAqcQB+AAR4c3IAEVRlc3QkRW51bSQkYW5vbiQxWUiOWYTWxdoCAAB4cQB+AAJxAH4ADXEAfgANcQB+AARxAH4ADQAAACpw") // IndexedSeqLike#Elements - check(new immutable.Range(0, 1, 1).iterator)("rO0ABXNyAChzY2FsYS5jb2xsZWN0aW9uLkluZGV4ZWRTZXFMaWtlJEVsZW1lbnRzGF+1cBwmcx0CAANJAANlbmRJAAVpbmRleEwABiRvdXRlcnQAIUxzY2FsYS9jb2xsZWN0aW9uL0luZGV4ZWRTZXFMaWtlO3hwAAAAAQAAAABzcgAgc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuUmFuZ2Vpu6NUqxUyDQIAB0kAA2VuZFoAB2lzRW1wdHlJAAtsYXN0RWxlbWVudEkAEG51bVJhbmdlRWxlbWVudHNJAAVzdGFydEkABHN0ZXBJAA90ZXJtaW5hbEVsZW1lbnR4cAAAAAEAAAAAAAAAAAEAAAAAAAAAAQAAAAE=" - , _.toList) + // TODO SI-8576 throws scala.UnitializedFieldError under -Xcheckinit + // check(new immutable.Range(0, 1, 1).iterator)("rO0ABXNyAChzY2FsYS5jb2xsZWN0aW9uLkluZGV4ZWRTZXFMaWtlJEVsZW1lbnRzGF+1cBwmcx0CAANJAANlbmRJAAVpbmRleEwABiRvdXRlcnQAIUxzY2FsYS9jb2xsZWN0aW9uL0luZGV4ZWRTZXFMaWtlO3hwAAAAAQAAAABzcgAgc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuUmFuZ2Vpu6NUqxUyDQIAB0kAA2VuZFoAB2lzRW1wdHlJAAtsYXN0RWxlbWVudEkAEG51bVJhbmdlRWxlbWVudHNJAAVzdGFydEkABHN0ZXBJAA90ZXJtaW5hbEVsZW1lbnR4cAAAAAEAAAAAAAAAAAEAAAAAAAAAAQAAAAE=" + // , _.toList) - check(new collection.concurrent.TrieMap[Any, Any]())( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLmNvbmN1cnJlbnQuVHJpZU1hcKckxpgOIYHPAwAETAALZXF1YWxpdHlvYmp0ABJMc2NhbGEvbWF0aC9FcXVpdjtMAApoYXNoaW5nb2JqdAAcTHNjYWxhL3V0aWwvaGFzaGluZy9IYXNoaW5nO0wABHJvb3R0ABJMamF2YS9sYW5nL09iamVjdDtMAAtyb290dXBkYXRlcnQAOUxqYXZhL3V0aWwvY29uY3VycmVudC9hdG9taWMvQXRvbWljUmVmZXJlbmNlRmllbGRVcGRhdGVyO3hwc3IAMnNjYWxhLmNvbGxlY3Rpb24uY29uY3VycmVudC5UcmllTWFwJE1hbmdsZWRIYXNoaW5nhTBoJQ/mgb0CAAB4cHNyABhzY2FsYS5tYXRoLkVxdWl2JCRhbm9uJDLBbyx4dy/qGwIAAHhwc3IANHNjYWxhLmNvbGxlY3Rpb24uY29uY3VycmVudC5UcmllTWFwU2VyaWFsaXphdGlvbkVuZCSbjdgbbGCt2gIAAHhweA==") + // check(new collection.concurrent.TrieMap[Any, Any]())( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLmNvbmN1cnJlbnQuVHJpZU1hcKckxpgOIYHPAwAETAALZXF1YWxpdHlvYmp0ABJMc2NhbGEvbWF0aC9FcXVpdjtMAApoYXNoaW5nb2JqdAAcTHNjYWxhL3V0aWwvaGFzaGluZy9IYXNoaW5nO0wABHJvb3R0ABJMamF2YS9sYW5nL09iamVjdDtMAAtyb290dXBkYXRlcnQAOUxqYXZhL3V0aWwvY29uY3VycmVudC9hdG9taWMvQXRvbWljUmVmZXJlbmNlRmllbGRVcGRhdGVyO3hwc3IAMnNjYWxhLmNvbGxlY3Rpb24uY29uY3VycmVudC5UcmllTWFwJE1hbmdsZWRIYXNoaW5nhTBoJQ/mgb0CAAB4cHNyABhzY2FsYS5tYXRoLkVxdWl2JCRhbm9uJDLBbyx4dy/qGwIAAHhwc3IANHNjYWxhLmNvbGxlY3Rpb24uY29uY3VycmVudC5UcmllTWFwU2VyaWFsaXphdGlvbkVuZCSbjdgbbGCt2gIAAHhweA==") // not sure why this one needs stable serialization. + + // TODO SI-8576 unstable under -Xcheckinit check(collection.convert.Wrappers)( "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") check(immutable.BitSet(1, 2, 3))( "rO0ABXNyAClzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5CaXRTZXQkQml0U2V0MR9dg8JGRI8UAgABSgAFZWxlbXN4cgAhc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuQml0U2V0Flz5Ms3qxsoCAAB4cAAAAAAAAAAO") @@ -130,7 +130,8 @@ object Test extends App { check(immutable.Queue())( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5RdWV1ZZY146W3qSuhAgACTAACaW50ACFMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvTGlzdDtMAANvdXRxAH4AAXhwc3IAMnNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3QkU2VyaWFsaXphdGlvblByb3h5AAAAAAAAAAEDAAB4cHNyACxzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0U2VyaWFsaXplRW5kJIpcY1v3UwttAgAAeHB4cQB+AAQ=") check(immutable.Queue(1, 2, 3))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5RdWV1ZZY146W3qSuhAgACTAACaW50ACFMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvTGlzdDtMAANvdXRxAH4AAXhwc3IAMnNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3QkU2VyaWFsaXphdGlvblByb3h5AAAAAAAAAAEDAAB4cHNyACxzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0U2VyaWFsaXplRW5kJIpcY1v3UwttAgAAeHB4c3EAfgADc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcQB+AAgAAAACc3EAfgAIAAAAA3EAfgAGeA==") - check(new immutable.Range(0, 1, 1))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5SYW5nZWm7o1SrFTINAgAHSQADZW5kWgAHaXNFbXB0eUkAC2xhc3RFbGVtZW50SQAQbnVtUmFuZ2VFbGVtZW50c0kABXN0YXJ0SQAEc3RlcEkAD3Rlcm1pbmFsRWxlbWVudHhwAAAAAQAAAAAAAAAAAQAAAAAAAAABAAAAAQ==") + // TODO SI-8576 throws scala.UnitializedFieldError under -Xcheckinit + // check(new immutable.Range(0, 1, 1))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5SYW5nZWm7o1SrFTINAgAHSQADZW5kWgAHaXNFbXB0eUkAC2xhc3RFbGVtZW50SQAQbnVtUmFuZ2VFbGVtZW50c0kABXN0YXJ0SQAEc3RlcEkAD3Rlcm1pbmFsRWxlbWVudHhwAAAAAQAAAAAAAAAAAQAAAAAAAAABAAAAAQ==") check(immutable.Set())( "rO0ABXNyAChzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TZXQkRW1wdHlTZXQk8Hk3TFN0uDYCAAB4cA==") check(immutable.Set(1))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TZXQkU2V0MREd3c4yqtWTAgABTAAFZWxlbTF0ABJMamF2YS9sYW5nL09iamVjdDt4cHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAAB") @@ -141,32 +142,42 @@ object Test extends App { check(immutable.Stack(1, 2, 3))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TdGFjaxtt3qEbMvq+AgABTAAFZWxlbXN0ACFMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvTGlzdDt4cHNyADJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5MaXN0JFNlcmlhbGl6YXRpb25Qcm94eQAAAAAAAAABAwAAeHBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABQAAAAJzcQB+AAUAAAADc3IALHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3RTZXJpYWxpemVFbmQkilxjW/dTC20CAAB4cHg=") - check(immutable.Stream(1, 2, 3))( "rO0ABXNyACZzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TdHJlYW0kQ29uc/ekjBXM3TlFAgADTAACaGR0ABJMamF2YS9sYW5nL09iamVjdDtMAAV0bEdlbnQAEUxzY2FsYS9GdW5jdGlvbjA7TAAFdGxWYWx0ACNMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvU3RyZWFtO3hyACFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TdHJlYW0552RDntM42gIAAHhwc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcgAtc2NhbGEuY29sbGVjdGlvbi5JdGVyYXRvciQkYW5vbmZ1biR0b1N0cmVhbSQxRWR4We0SX0UCAAFMAAYkb3V0ZXJ0ABtMc2NhbGEvY29sbGVjdGlvbi9JdGVyYXRvcjt4cHNyAChzY2FsYS5jb2xsZWN0aW9uLkluZGV4ZWRTZXFMaWtlJEVsZW1lbnRzGF+1cBwmcx0CAANJAANlbmRJAAVpbmRleEwABiRvdXRlcnQAIUxzY2FsYS9jb2xsZWN0aW9uL0luZGV4ZWRTZXFMaWtlO3hwAAAAAwAAAAFzcgArc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLldyYXBwZWRBcnJheSRvZkludMmRLBcI15VjAgABWwAFYXJyYXl0AAJbSXhwdXIAAltJTbpgJnbqsqUCAAB4cAAAAAMAAAABAAAAAgAAAANw") + // TODO SI-8576 Uninitialized field: IndexedSeqLike.scala: 56 + // check(immutable.Stream(1, 2, 3))( "rO0ABXNyACZzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TdHJlYW0kQ29uc/ekjBXM3TlFAgADTAACaGR0ABJMamF2YS9sYW5nL09iamVjdDtMAAV0bEdlbnQAEUxzY2FsYS9GdW5jdGlvbjA7TAAFdGxWYWx0ACNMc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvU3RyZWFtO3hyACFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5TdHJlYW0552RDntM42gIAAHhwc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcgAtc2NhbGEuY29sbGVjdGlvbi5JdGVyYXRvciQkYW5vbmZ1biR0b1N0cmVhbSQxRWR4We0SX0UCAAFMAAYkb3V0ZXJ0ABtMc2NhbGEvY29sbGVjdGlvbi9JdGVyYXRvcjt4cHNyAChzY2FsYS5jb2xsZWN0aW9uLkluZGV4ZWRTZXFMaWtlJEVsZW1lbnRzGF+1cBwmcx0CAANJAANlbmRJAAVpbmRleEwABiRvdXRlcnQAIUxzY2FsYS9jb2xsZWN0aW9uL0luZGV4ZWRTZXFMaWtlO3hwAAAAAwAAAAFzcgArc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLldyYXBwZWRBcnJheSRvZkludMmRLBcI15VjAgABWwAFYXJyYXl0AAJbSXhwdXIAAltJTbpgJnbqsqUCAAB4cAAAAAMAAAABAAAAAgAAAANw") check(immutable.TreeSet[Int]())( "rO0ABXNyACJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5UcmVlU2V0sRdVIDjbWAsCAAJMAAhvcmRlcmluZ3QAFUxzY2FsYS9tYXRoL09yZGVyaW5nO0wABHRyZWV0AC5Mc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvUmVkQmxhY2tUcmVlJFRyZWU7eHBzcgAYc2NhbGEubWF0aC5PcmRlcmluZyRJbnQkC4BMdr1Z51wCAAB4cHA=") - check(immutable.TreeSet(1, 2, 3))( "rO0ABXNyACJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5UcmVlU2V0sRdVIDjbWAsCAAJMAAhvcmRlcmluZ3QAFUxzY2FsYS9tYXRoL09yZGVyaW5nO0wABHRyZWV0AC5Mc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvUmVkQmxhY2tUcmVlJFRyZWU7eHBzcgAYc2NhbGEubWF0aC5PcmRlcmluZyRJbnQkC4BMdr1Z51wCAAB4cHNyADFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5SZWRCbGFja1RyZWUkQmxhY2tUcmVlzRxnCKenVAECAAB4cgAsc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuUmVkQmxhY2tUcmVlJFRyZWVrqCSyHJbsMgIABUkABWNvdW50TAADa2V5dAASTGphdmEvbGFuZy9PYmplY3Q7TAAEbGVmdHEAfgACTAAFcmlnaHRxAH4AAkwABXZhbHVlcQB+AAh4cAAAAANzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAnNxAH4ABgAAAAFzcQB+AAoAAAABcHBzcgAXc2NhbGEucnVudGltZS5Cb3hlZFVuaXR0pn1HHezLmgIAAHhwc3EAfgAGAAAAAXNxAH4ACgAAAANwcHEAfgAQcQB+ABA=") - - check(mutable.ArrayBuffer(1, 2, 3))( "rO0ABXNyACRzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuQXJyYXlCdWZmZXIVOLBTg4KOcwIAA0kAC2luaXRpYWxTaXplSQAFc2l6ZTBbAAVhcnJheXQAE1tMamF2YS9sYW5nL09iamVjdDt4cAAAABAAAAADdXIAE1tMamF2YS5sYW5nLk9iamVjdDuQzlifEHMpbAIAAHhwAAAAEHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAABc3EAfgAFAAAAAnNxAH4ABQAAAANwcHBwcHBwcHBwcHBw") - check(mutable.ArraySeq(1, 2, 3))( "rO0ABXNyACFzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuQXJyYXlTZXEVPD3SKEkOcwIAAkkABmxlbmd0aFsABWFycmF5dAATW0xqYXZhL2xhbmcvT2JqZWN0O3hwAAAAA3VyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAANzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABQAAAAJzcQB+AAUAAAAD") + + // TODO SI-8576 unstable under -Xcheckinit + // check(immutable.TreeSet(1, 2, 3))( "rO0ABXNyACJzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5UcmVlU2V0sRdVIDjbWAsCAAJMAAhvcmRlcmluZ3QAFUxzY2FsYS9tYXRoL09yZGVyaW5nO0wABHRyZWV0AC5Mc2NhbGEvY29sbGVjdGlvbi9pbW11dGFibGUvUmVkQmxhY2tUcmVlJFRyZWU7eHBzcgAYc2NhbGEubWF0aC5PcmRlcmluZyRJbnQkC4BMdr1Z51wCAAB4cHNyADFzY2FsYS5jb2xsZWN0aW9uLmltbXV0YWJsZS5SZWRCbGFja1RyZWUkQmxhY2tUcmVlzRxnCKenVAECAAB4cgAsc2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuUmVkQmxhY2tUcmVlJFRyZWVrqCSyHJbsMgIABUkABWNvdW50TAADa2V5dAASTGphdmEvbGFuZy9PYmplY3Q7TAAEbGVmdHEAfgACTAAFcmlnaHRxAH4AAkwABXZhbHVlcQB+AAh4cAAAAANzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAnNxAH4ABgAAAAFzcQB+AAoAAAABcHBzcgAXc2NhbGEucnVudGltZS5Cb3hlZFVuaXR0pn1HHezLmgIAAHhwc3EAfgAGAAAAAXNxAH4ACgAAAANwcHEAfgAQcQB+ABA=") + + // TODO SI-8576 Uninitialized field under -Xcheckinit + // check(mutable.ArrayBuffer(1, 2, 3))( "rO0ABXNyACRzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuQXJyYXlCdWZmZXIVOLBTg4KOcwIAA0kAC2luaXRpYWxTaXplSQAFc2l6ZTBbAAVhcnJheXQAE1tMamF2YS9sYW5nL09iamVjdDt4cAAAABAAAAADdXIAE1tMamF2YS5sYW5nLk9iamVjdDuQzlifEHMpbAIAAHhwAAAAEHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAABc3EAfgAFAAAAAnNxAH4ABQAAAANwcHBwcHBwcHBwcHBw") + // TODO SI-8576 Uninitialized field under -Xcheckinit + // check(mutable.ArraySeq(1, 2, 3))( "rO0ABXNyACFzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuQXJyYXlTZXEVPD3SKEkOcwIAAkkABmxlbmd0aFsABWFycmF5dAATW0xqYXZhL2xhbmcvT2JqZWN0O3hwAAAAA3VyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAANzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABQAAAAJzcQB+AAUAAAAD") check(mutable.ArrayStack(1, 2, 3))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuQXJyYXlTdGFja3bdxXbcnLBeAgACSQAqc2NhbGEkY29sbGVjdGlvbiRtdXRhYmxlJEFycmF5U3RhY2skJGluZGV4WwAqc2NhbGEkY29sbGVjdGlvbiRtdXRhYmxlJEFycmF5U3RhY2skJHRhYmxldAATW0xqYXZhL2xhbmcvT2JqZWN0O3hwAAAAA3VyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAANzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAA3NxAH4ABQAAAAJzcQB+AAUAAAAB") check(mutable.DoubleLinkedList(1, 2, 3))( "rO0ABXNyAClzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuRG91YmxlTGlua2VkTGlzdI73LKsKRr1RAgADTAAEZWxlbXQAEkxqYXZhL2xhbmcvT2JqZWN0O0wABG5leHR0AB5Mc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL1NlcTtMAARwcmV2cQB+AAJ4cHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAABc3EAfgAAc3EAfgAEAAAAAnNxAH4AAHNxAH4ABAAAAANzcQB+AABwcQB+AAtxAH4ACXEAfgAHcQB+AANw") check(mutable.HashMap())( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuSGFzaE1hcAAAAAAAAAABAwAAeHB3DQAAAu4AAAAAAAAABAB4") check(mutable.HashMap(1 -> 1))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuSGFzaE1hcAAAAAAAAAABAwAAeHB3DQAAAu4AAAABAAAABABzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXEAfgAEeA==") check(mutable.HashSet(1, 2, 3))( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuSGFzaFNldAAAAAAAAAABAwAAeHB3DQAAAcIAAAADAAAABQBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJzcQB+AAIAAAADeA==") - check(new mutable.History())( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuSGlzdG9yeUhuXxDIFJrsAgACSQAKbWF4SGlzdG9yeUwAA2xvZ3QAIExzY2FsYS9jb2xsZWN0aW9uL211dGFibGUvUXVldWU7eHAAAAPoc3IAHnNjYWxhLmNvbGxlY3Rpb24ubXV0YWJsZS5RdWV1ZbjMURVfOuHHAgAAeHIAJHNjYWxhLmNvbGxlY3Rpb24ubXV0YWJsZS5NdXRhYmxlTGlzdFJpnjJ+gFbAAgADSQADbGVuTAAGZmlyc3QwdAAlTHNjYWxhL2NvbGxlY3Rpb24vbXV0YWJsZS9MaW5rZWRMaXN0O0wABWxhc3QwcQB+AAV4cAAAAABzcgAjc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLkxpbmtlZExpc3Sak+nGCZHaUQIAAkwABGVsZW10ABJMamF2YS9sYW5nL09iamVjdDtMAARuZXh0dAAeTHNjYWxhL2NvbGxlY3Rpb24vbXV0YWJsZS9TZXE7eHBwcQB+AApxAH4ACg==") + // TODO SI-8576 Uninitialized field under -Xcheckinit + // check(new mutable.History())( "rO0ABXNyACBzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuSGlzdG9yeUhuXxDIFJrsAgACSQAKbWF4SGlzdG9yeUwAA2xvZ3QAIExzY2FsYS9jb2xsZWN0aW9uL211dGFibGUvUXVldWU7eHAAAAPoc3IAHnNjYWxhLmNvbGxlY3Rpb24ubXV0YWJsZS5RdWV1ZbjMURVfOuHHAgAAeHIAJHNjYWxhLmNvbGxlY3Rpb24ubXV0YWJsZS5NdXRhYmxlTGlzdFJpnjJ+gFbAAgADSQADbGVuTAAGZmlyc3QwdAAlTHNjYWxhL2NvbGxlY3Rpb24vbXV0YWJsZS9MaW5rZWRMaXN0O0wABWxhc3QwcQB+AAV4cAAAAABzcgAjc2NhbGEuY29sbGVjdGlvbi5tdXRhYmxlLkxpbmtlZExpc3Sak+nGCZHaUQIAAkwABGVsZW10ABJMamF2YS9sYW5nL09iamVjdDtMAARuZXh0dAAeTHNjYWxhL2NvbGxlY3Rpb24vbXV0YWJsZS9TZXE7eHBwcQB+AApxAH4ACg==") check(mutable.LinkedHashMap(1 -> 2))( "rO0ABXNyACZzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuTGlua2VkSGFzaE1hcAAAAAAAAAABAwAAeHB3DQAAAu4AAAABAAAABABzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJ4") check(mutable.LinkedHashSet(1, 2, 3))( "rO0ABXNyACZzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuTGlua2VkSGFzaFNldAAAAAAAAAABAwAAeHB3DQAAAu4AAAADAAAABABzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4AAgAAAAJzcQB+AAIAAAADeA==") check(mutable.LinkedList(1, 2, 3))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuTGlua2VkTGlzdJqT6cYJkdpRAgACTAAEZWxlbXQAEkxqYXZhL2xhbmcvT2JqZWN0O0wABG5leHR0AB5Mc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL1NlcTt4cHNyABFqYXZhLmxhbmcuSW50ZWdlchLioKT3gYc4AgABSQAFdmFsdWV4cgAQamF2YS5sYW5nLk51bWJlcoaslR0LlOCLAgAAeHAAAAABc3EAfgAAc3EAfgAEAAAAAnNxAH4AAHNxAH4ABAAAAANzcQB+AABwcQB+AAs=") - check(mutable.ListBuffer(1, 2, 3))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuTGlzdEJ1ZmZlci9y9I7QyWzGAwAEWgAIZXhwb3J0ZWRJAANsZW5MAAVsYXN0MHQAKUxzY2FsYS9jb2xsZWN0aW9uL2ltbXV0YWJsZS8kY29sb24kY29sb247TAAqc2NhbGEkY29sbGVjdGlvbiRtdXRhYmxlJExpc3RCdWZmZXIkJHN0YXJ0dAAhTHNjYWxhL2NvbGxlY3Rpb24vaW1tdXRhYmxlL0xpc3Q7eHBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABAAAAAJzcQB+AAQAAAADc3IALHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3RTZXJpYWxpemVFbmQkilxjW/dTC20CAAB4cHcFAAAAAAN4") + + // TODO SI-8576 unstable under -Xcheckinit + // check(mutable.ListBuffer(1, 2, 3))( "rO0ABXNyACNzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuTGlzdEJ1ZmZlci9y9I7QyWzGAwAEWgAIZXhwb3J0ZWRJAANsZW5MAAVsYXN0MHQAKUxzY2FsYS9jb2xsZWN0aW9uL2ltbXV0YWJsZS8kY29sb24kY29sb247TAAqc2NhbGEkY29sbGVjdGlvbiRtdXRhYmxlJExpc3RCdWZmZXIkJHN0YXJ0dAAhTHNjYWxhL2NvbGxlY3Rpb24vaW1tdXRhYmxlL0xpc3Q7eHBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABAAAAAJzcQB+AAQAAAADc3IALHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLkxpc3RTZXJpYWxpemVFbmQkilxjW/dTC20CAAB4cHcFAAAAAAN4") check(new mutable.StringBuilder(new java.lang.StringBuilder("123")))( "rO0ABXNyACZzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuU3RyaW5nQnVpbGRlcomvqgGv1tTxAgABTAAKdW5kZXJseWluZ3QAGUxqYXZhL2xhbmcvU3RyaW5nQnVpbGRlcjt4cHNyABdqYXZhLmxhbmcuU3RyaW5nQnVpbGRlcjzV+xRaTGrLAwAAeHB3BAAAAAN1cgACW0OwJmaw4l2ErAIAAHhwAAAAEwAxADIAMwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeA==") check(mutable.UnrolledBuffer[Int]())( "rO0ABXNyACdzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuVW5yb2xsZWRCdWZmZXIAAAAAAAAAAQMAAUwAA3RhZ3QAGExzY2FsYS9yZWZsZWN0L0NsYXNzVGFnO3hwc3IAJXNjYWxhLnJlZmxlY3QuTWFuaWZlc3RGYWN0b3J5JCRhbm9uJDnN+aJJU2O1UgIAAHhyABxzY2FsYS5yZWZsZWN0LkFueVZhbE1hbmlmZXN0AAAAAAAAAAECAAFMAAh0b1N0cmluZ3QAEkxqYXZhL2xhbmcvU3RyaW5nO3hwdAADSW50dwQAAAAAeA==") import collection.parallel check(parallel.immutable.ParHashMap(1 -> 2))( "rO0ABXNyAC5zY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLmltbXV0YWJsZS5QYXJIYXNoTWFwAAAAAAAAAAECAANMAA9TY2FuTGVhZiRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2NhbkxlYWYkO0wAD1NjYW5Ob2RlJG1vZHVsZXQANUxzY2FsYS9jb2xsZWN0aW9uL3BhcmFsbGVsL1Bhckl0ZXJhYmxlTGlrZSRTY2FuTm9kZSQ7TAAEdHJpZXQAJExzY2FsYS9jb2xsZWN0aW9uL2ltbXV0YWJsZS9IYXNoTWFwO3hwcHBzcgA1c2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuSGFzaE1hcCRTZXJpYWxpemF0aW9uUHJveHkAAAAAAAAAAgMAAHhwdwQAAAABc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcQB+AAcAAAACeA==") check(parallel.immutable.ParHashSet(1, 2, 3))( "rO0ABXNyAC5zY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLmltbXV0YWJsZS5QYXJIYXNoU2V0AAAAAAAAAAECAANMAA9TY2FuTGVhZiRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2NhbkxlYWYkO0wAD1NjYW5Ob2RlJG1vZHVsZXQANUxzY2FsYS9jb2xsZWN0aW9uL3BhcmFsbGVsL1Bhckl0ZXJhYmxlTGlrZSRTY2FuTm9kZSQ7TAAEdHJpZXQAJExzY2FsYS9jb2xsZWN0aW9uL2ltbXV0YWJsZS9IYXNoU2V0O3hwcHBzcgA1c2NhbGEuY29sbGVjdGlvbi5pbW11dGFibGUuSGFzaFNldCRTZXJpYWxpemF0aW9uUHJveHkAAAAAAAAAAgMAAHhwdwQAAAADc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcQB+AAcAAAACc3EAfgAHAAAAA3g=") - check(new parallel.immutable.ParRange(new Range(0, 1, 2)))( "rO0ABXNyACxzY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLmltbXV0YWJsZS5QYXJSYW5nZQAAAAAAAAABAgAETAAXUGFyUmFuZ2VJdGVyYXRvciRtb2R1bGV0AEBMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9pbW11dGFibGUvUGFyUmFuZ2UkUGFyUmFuZ2VJdGVyYXRvciQ7TAAPU2NhbkxlYWYkbW9kdWxldAA1THNjYWxhL2NvbGxlY3Rpb24vcGFyYWxsZWwvUGFySXRlcmFibGVMaWtlJFNjYW5MZWFmJDtMAA9TY2FuTm9kZSRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2Nhbk5vZGUkO0wABXJhbmdldAAiTHNjYWxhL2NvbGxlY3Rpb24vaW1tdXRhYmxlL1JhbmdlO3hwcHBwc3IAIHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLlJhbmdlabujVKsVMg0CAAdJAANlbmRaAAdpc0VtcHR5SQALbGFzdEVsZW1lbnRJABBudW1SYW5nZUVsZW1lbnRzSQAFc3RhcnRJAARzdGVwSQAPdGVybWluYWxFbGVtZW50eHAAAAABAAAAAAAAAAABAAAAAAAAAAIAAAAC") - check(parallel.mutable.ParArray(1, 2, 3))( "rO0ABXNyACpzY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLm11dGFibGUuUGFyQXJyYXkAAAAAAAAAAQMABEwAF1BhckFycmF5SXRlcmF0b3IkbW9kdWxldAA+THNjYWxhL2NvbGxlY3Rpb24vcGFyYWxsZWwvbXV0YWJsZS9QYXJBcnJheSRQYXJBcnJheUl0ZXJhdG9yJDtMAA9TY2FuTGVhZiRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2NhbkxlYWYkO0wAD1NjYW5Ob2RlJG1vZHVsZXQANUxzY2FsYS9jb2xsZWN0aW9uL3BhcmFsbGVsL1Bhckl0ZXJhYmxlTGlrZSRTY2FuTm9kZSQ7TAAIYXJyYXlzZXF0ACNMc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL0FycmF5U2VxO3hwcHBwc3IAMXNjYWxhLmNvbGxlY3Rpb24ucGFyYWxsZWwubXV0YWJsZS5FeHBvc2VkQXJyYXlTZXGx2OTefAodSQIAAkkABmxlbmd0aFsABWFycmF5dAATW0xqYXZhL2xhbmcvT2JqZWN0O3hyACFzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuQXJyYXlTZXEVPD3SKEkOcwIAAkkABmxlbmd0aFsABWFycmF5cQB+AAd4cAAAAAN1cgATW0xqYXZhLmxhbmcuT2JqZWN0O5DOWJ8QcylsAgAAeHAAAAADcHBwAAAAA3VxAH4ACgAAABBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ADQAAAAJzcQB+AA0AAAADcHBwcHBwcHBwcHBwcHg=") + // TODO SI-8576 Uninitialized field under -Xcheckinit + // check(new parallel.immutable.ParRange(new Range(0, 1, 2)))( "rO0ABXNyACxzY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLmltbXV0YWJsZS5QYXJSYW5nZQAAAAAAAAABAgAETAAXUGFyUmFuZ2VJdGVyYXRvciRtb2R1bGV0AEBMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9pbW11dGFibGUvUGFyUmFuZ2UkUGFyUmFuZ2VJdGVyYXRvciQ7TAAPU2NhbkxlYWYkbW9kdWxldAA1THNjYWxhL2NvbGxlY3Rpb24vcGFyYWxsZWwvUGFySXRlcmFibGVMaWtlJFNjYW5MZWFmJDtMAA9TY2FuTm9kZSRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2Nhbk5vZGUkO0wABXJhbmdldAAiTHNjYWxhL2NvbGxlY3Rpb24vaW1tdXRhYmxlL1JhbmdlO3hwcHBwc3IAIHNjYWxhLmNvbGxlY3Rpb24uaW1tdXRhYmxlLlJhbmdlabujVKsVMg0CAAdJAANlbmRaAAdpc0VtcHR5SQALbGFzdEVsZW1lbnRJABBudW1SYW5nZUVsZW1lbnRzSQAFc3RhcnRJAARzdGVwSQAPdGVybWluYWxFbGVtZW50eHAAAAABAAAAAAAAAAABAAAAAAAAAAIAAAAC") + // TODO SI-8576 unstable under -Xcheckinit + // check(parallel.mutable.ParArray(1, 2, 3))( "rO0ABXNyACpzY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLm11dGFibGUuUGFyQXJyYXkAAAAAAAAAAQMABEwAF1BhckFycmF5SXRlcmF0b3IkbW9kdWxldAA+THNjYWxhL2NvbGxlY3Rpb24vcGFyYWxsZWwvbXV0YWJsZS9QYXJBcnJheSRQYXJBcnJheUl0ZXJhdG9yJDtMAA9TY2FuTGVhZiRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2NhbkxlYWYkO0wAD1NjYW5Ob2RlJG1vZHVsZXQANUxzY2FsYS9jb2xsZWN0aW9uL3BhcmFsbGVsL1Bhckl0ZXJhYmxlTGlrZSRTY2FuTm9kZSQ7TAAIYXJyYXlzZXF0ACNMc2NhbGEvY29sbGVjdGlvbi9tdXRhYmxlL0FycmF5U2VxO3hwcHBwc3IAMXNjYWxhLmNvbGxlY3Rpb24ucGFyYWxsZWwubXV0YWJsZS5FeHBvc2VkQXJyYXlTZXGx2OTefAodSQIAAkkABmxlbmd0aFsABWFycmF5dAATW0xqYXZhL2xhbmcvT2JqZWN0O3hyACFzY2FsYS5jb2xsZWN0aW9uLm11dGFibGUuQXJyYXlTZXEVPD3SKEkOcwIAAkkABmxlbmd0aFsABWFycmF5cQB+AAd4cAAAAAN1cgATW0xqYXZhLmxhbmcuT2JqZWN0O5DOWJ8QcylsAgAAeHAAAAADcHBwAAAAA3VxAH4ACgAAABBzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ADQAAAAJzcQB+AA0AAAADcHBwcHBwcHBwcHBwcHg=") check(parallel.mutable.ParHashMap(1 -> 2))( "rO0ABXNyACxzY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLm11dGFibGUuUGFySGFzaE1hcAAAAAAAAAABAwACTAAPU2NhbkxlYWYkbW9kdWxldAA1THNjYWxhL2NvbGxlY3Rpb24vcGFyYWxsZWwvUGFySXRlcmFibGVMaWtlJFNjYW5MZWFmJDtMAA9TY2FuTm9kZSRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2Nhbk5vZGUkO3hwcHB3DQAAAu4AAAABAAAABAFzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABAAAAAJ4") check(parallel.mutable.ParHashSet(1, 2, 3))( "rO0ABXNyACxzY2FsYS5jb2xsZWN0aW9uLnBhcmFsbGVsLm11dGFibGUuUGFySGFzaFNldAAAAAAAAAABAwACTAAPU2NhbkxlYWYkbW9kdWxldAA1THNjYWxhL2NvbGxlY3Rpb24vcGFyYWxsZWwvUGFySXRlcmFibGVMaWtlJFNjYW5MZWFmJDtMAA9TY2FuTm9kZSRtb2R1bGV0ADVMc2NhbGEvY29sbGVjdGlvbi9wYXJhbGxlbC9QYXJJdGVyYWJsZUxpa2UkU2Nhbk5vZGUkO3hwcHB3DQAAAcIAAAADAAAAGwFzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAXNxAH4ABAAAAAJzcQB+AAQAAAADeA==") From b523827ecb11ae671da92fbb4853d83e25852ad4 Mon Sep 17 00:00:00 2001 From: Todd Vierling Date: Sat, 10 May 2014 17:23:44 -0400 Subject: [PATCH 241/826] Make PartialFunction.OrElse extend AbstractPartialFunction. This shaves a few kB off of the generated class file. --- src/library/scala/PartialFunction.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/library/scala/PartialFunction.scala b/src/library/scala/PartialFunction.scala index 7f4a9dc45d70..a0b18f7f3342 100644 --- a/src/library/scala/PartialFunction.scala +++ b/src/library/scala/PartialFunction.scala @@ -156,10 +156,10 @@ trait PartialFunction[-A, +B] extends (A => B) { self => object PartialFunction { /** Composite function produced by `PartialFunction#orElse` method */ - private class OrElse[-A, +B] (f1: PartialFunction[A, B], f2: PartialFunction[A, B]) extends PartialFunction[A, B] { + private class OrElse[-A, +B] (f1: PartialFunction[A, B], f2: PartialFunction[A, B]) extends scala.runtime.AbstractPartialFunction[A, B] { def isDefinedAt(x: A) = f1.isDefinedAt(x) || f2.isDefinedAt(x) - def apply(x: A): B = f1.applyOrElse(x, f2) + override def apply(x: A): B = f1.applyOrElse(x, f2) override def applyOrElse[A1 <: A, B1 >: B](x: A1, default: A1 => B1): B1 = { val z = f1.applyOrElse(x, checkFallback[B]) From f13c07fe29d27bdc75423be6d3bf5458175bec90 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sun, 11 May 2014 13:50:09 +0200 Subject: [PATCH 242/826] SI-8578 Avoid fresh name clashes under -Ydelambdafy:method It is important to append the fresh 'N' after '$'. Otherwise, we find out the hard way that ("foo$11" + "1") == ("foo$1" + "11"). --- .../scala/tools/nsc/transform/Delambdafy.scala | 2 +- test/files/pos/t8578.flags | 1 + test/files/pos/t8578.scala | 18 ++++++++++++++++++ 3 files changed, 20 insertions(+), 1 deletion(-) create mode 100644 test/files/pos/t8578.flags create mode 100644 test/files/pos/t8578.scala diff --git a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala index 1468680fe0a8..d66e53edca9b 100644 --- a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala +++ b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala @@ -238,7 +238,7 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre // - reinstate the assertion in `Erasure.resolveAnonymousBridgeClash` val suffix = "$lambda$" + ( if (funOwner.isPrimaryConstructor) "" - else "$" + funOwner.name + else "$" + funOwner.name + "$" ) val name = unit.freshTypeName(s"${oldClass.name.decode}$suffix") diff --git a/test/files/pos/t8578.flags b/test/files/pos/t8578.flags new file mode 100644 index 000000000000..48b438ddf86a --- /dev/null +++ b/test/files/pos/t8578.flags @@ -0,0 +1 @@ +-Ydelambdafy:method diff --git a/test/files/pos/t8578.scala b/test/files/pos/t8578.scala new file mode 100644 index 000000000000..879b5f55504d --- /dev/null +++ b/test/files/pos/t8578.scala @@ -0,0 +1,18 @@ +class DuplicateClassName { + () => { + {() => ()} + {() => ()} + {() => ()} + {() => ()} + {() => ()} + {() => ()} + {() => ()} + {() => ()} + {() => ()} + {() => () => ()} + {() => ()} + } +} +// Was: +// Different class symbols have the same bytecode-level internal name: +// name: DuplicateClassName$lambda$$$anonfun$111 \ No newline at end of file From 32514aac8b0f301be5bf451eb68f28e9bd7f929a Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sun, 11 May 2014 13:53:04 +0200 Subject: [PATCH 243/826] SI-8578 Avoid another potential fresh name clash No test case for this one, but see the preceding commit for the class of bug that I'm trying to avoid. --- src/compiler/scala/tools/nsc/transform/Delambdafy.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala index d66e53edca9b..1f8ab7e88799 100644 --- a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala +++ b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala @@ -132,7 +132,7 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre } val params = ((optionSymbol(thisProxy) map {proxy:Symbol => ValDef(proxy)}) ++ (target.paramss.flatten map ValDef.apply)).toList - val methSym = oldClass.newMethod(unit.freshTermName(nme.accessor.toString()), target.pos, FINAL | BRIDGE | SYNTHETIC | PROTECTED | STATIC) + val methSym = oldClass.newMethod(unit.freshTermName(nme.accessor.toString() + "$"), target.pos, FINAL | BRIDGE | SYNTHETIC | PROTECTED | STATIC) val paramSyms = params map {param => methSym.newSyntheticValueParam(param.symbol.tpe, param.name) } From 7f08e00a3aa0f59314767313977d9f2899a80cd9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rui=20Gon=C3=A7alves?= Date: Mon, 12 May 2014 00:29:44 +0100 Subject: [PATCH 244/826] SI-8553 WrappedArray throws exception on lastIndexWhere when index out of range Adds a check in `IndexedSeqOptimized#lastIndexWhere(A => Boolean, Int)` to begin searching in the end of the collection if `end` is greater than the collection's length. Discussed in https://groups.google.com/d/topic/scala-internals/-MacXivbY0Q/discussion. --- .../scala/collection/IndexedSeqOptimized.scala | 2 +- .../collection/IndexedSeqOptimizedTest.scala | 16 ++++++++++++++++ 2 files changed, 17 insertions(+), 1 deletion(-) create mode 100644 test/junit/scala/collection/IndexedSeqOptimizedTest.scala diff --git a/src/library/scala/collection/IndexedSeqOptimized.scala b/src/library/scala/collection/IndexedSeqOptimized.scala index ade04e4de884..42cb37aa24c7 100755 --- a/src/library/scala/collection/IndexedSeqOptimized.scala +++ b/src/library/scala/collection/IndexedSeqOptimized.scala @@ -206,7 +206,7 @@ trait IndexedSeqOptimized[+A, +Repr] extends Any with IndexedSeqLike[A, Repr] { override /*SeqLike*/ def lastIndexWhere(p: A => Boolean, end: Int): Int = { - var i = end + var i = math.min(end, length - 1) while (i >= 0 && !p(this(i))) i -= 1 i } diff --git a/test/junit/scala/collection/IndexedSeqOptimizedTest.scala b/test/junit/scala/collection/IndexedSeqOptimizedTest.scala new file mode 100644 index 000000000000..e5382907af59 --- /dev/null +++ b/test/junit/scala/collection/IndexedSeqOptimizedTest.scala @@ -0,0 +1,16 @@ +package scala.collection + +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 +import org.junit.Assert._ +import org.junit.Test + +@RunWith(classOf[JUnit4]) +class IndexedSeqOptimizedTest { + + @Test + def notThrowsAnExceptionInLastIndexOf() { + assertEquals(0, (Array(2): collection.mutable.WrappedArray[Int]).lastIndexWhere(_ => true, 1)) + assertEquals(2, "abc123".lastIndexWhere(_.isLetter, 6)) + } +} From 3a8d9fb6be1f11554401d305ef218ea4e25ffa06 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Mon, 12 May 2014 22:53:31 +0200 Subject: [PATCH 245/826] SI-8582 Pending test for InnerClasses bug in GenBCode As seen in a runtime reflection failure in Slick during a GenBCode enabled run of our beloved Community Build. --- test/files/run/t8582.check | 2 ++ test/files/run/t8582.scala | 16 ++++++++++++++++ test/pending/run/t8582-bcode.check | 2 ++ test/pending/run/t8582-bcode.flags | 1 + test/pending/run/t8582-bcode.scala | 16 ++++++++++++++++ 5 files changed, 37 insertions(+) create mode 100644 test/files/run/t8582.check create mode 100644 test/files/run/t8582.scala create mode 100644 test/pending/run/t8582-bcode.check create mode 100644 test/pending/run/t8582-bcode.flags create mode 100644 test/pending/run/t8582-bcode.scala diff --git a/test/files/run/t8582.check b/test/files/run/t8582.check new file mode 100644 index 000000000000..7e9675698698 --- /dev/null +++ b/test/files/run/t8582.check @@ -0,0 +1,2 @@ +class p1.p2.Singleton$Singleton$ +List(class p1.p2.Singleton$Singleton$Singleton$) diff --git a/test/files/run/t8582.scala b/test/files/run/t8582.scala new file mode 100644 index 000000000000..844ab8ac1436 --- /dev/null +++ b/test/files/run/t8582.scala @@ -0,0 +1,16 @@ +package p1 { + package p2 { + object Singleton { + object Singleton { + object Singleton + } + } + } +} + + +object Test extends App { + import p1.p2._ + println(Singleton.Singleton.getClass) + println(Singleton.Singleton.getClass.getDeclaredClasses.toList) +} diff --git a/test/pending/run/t8582-bcode.check b/test/pending/run/t8582-bcode.check new file mode 100644 index 000000000000..7e9675698698 --- /dev/null +++ b/test/pending/run/t8582-bcode.check @@ -0,0 +1,2 @@ +class p1.p2.Singleton$Singleton$ +List(class p1.p2.Singleton$Singleton$Singleton$) diff --git a/test/pending/run/t8582-bcode.flags b/test/pending/run/t8582-bcode.flags new file mode 100644 index 000000000000..c30091d3de5d --- /dev/null +++ b/test/pending/run/t8582-bcode.flags @@ -0,0 +1 @@ +-Ybackend:GenBCode diff --git a/test/pending/run/t8582-bcode.scala b/test/pending/run/t8582-bcode.scala new file mode 100644 index 000000000000..844ab8ac1436 --- /dev/null +++ b/test/pending/run/t8582-bcode.scala @@ -0,0 +1,16 @@ +package p1 { + package p2 { + object Singleton { + object Singleton { + object Singleton + } + } + } +} + + +object Test extends App { + import p1.p2._ + println(Singleton.Singleton.getClass) + println(Singleton.Singleton.getClass.getDeclaredClasses.toList) +} From dc5251eda0a48b9e749a157d689d3ea497ea7045 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Thu, 17 Apr 2014 01:02:58 -0700 Subject: [PATCH 246/826] SI-8507 Avoid lazy val in StringContext This mild refactor eliminates the lazy val StringBuilder and arguably makes the code easier to read. There is a small unit test but no benchmark to prove anything useful about performance. The ticket notes contention due to lazy implementation. --- src/library/scala/StringContext.scala | 97 ++++++++++++------------ test/junit/scala/StringContextTest.scala | 51 +++++++++++++ 2 files changed, 101 insertions(+), 47 deletions(-) create mode 100644 test/junit/scala/StringContextTest.scala diff --git a/src/library/scala/StringContext.scala b/src/library/scala/StringContext.scala index cd928a2b61f9..c0468e8b021d 100644 --- a/src/library/scala/StringContext.scala +++ b/src/library/scala/StringContext.scala @@ -8,6 +8,9 @@ package scala +import java.lang.{ StringBuilder => JLSBuilder } +import scala.annotation.tailrec + /** This class provides the basic mechanism to do String Interpolation. * String Interpolation allows users * to embed variable references directly in *processed* string literals. @@ -41,7 +44,7 @@ package scala * val x: JSONObject = json"{ a: $a }" * }}} * - * Here the `JsonHelper` extenion class implicitly adds the `json` method to + * Here the `JsonHelper` extension class implicitly adds the `json` method to * `StringContext` which can be used for `json` string literals. * * @since 2.10.0 @@ -118,7 +121,7 @@ case class StringContext(parts: String*) { checkLengths(args) val pi = parts.iterator val ai = args.iterator - val bldr = new java.lang.StringBuilder(process(pi.next())) + val bldr = new JLSBuilder(process(pi.next())) while (ai.hasNext) { bldr append ai.next bldr append process(pi.next()) @@ -186,60 +189,60 @@ object StringContext { */ def treatEscapes(str: String): String = treatEscapes0(str, strict = false) + /** Treats escapes, but disallows octal escape sequences. */ def processEscapes(str: String): String = treatEscapes0(str, strict = true) private def treatEscapes0(str: String, strict: Boolean): String = { - lazy val bldr = new java.lang.StringBuilder val len = str.length - var start = 0 - var cur = 0 - var idx = 0 - def output(ch: Char) = { - bldr.append(str, start, cur) - bldr append ch - start = idx - } - while (idx < len) { - cur = idx - if (str(idx) == '\\') { - idx += 1 - if (idx >= len) throw new InvalidEscapeException(str, cur) - if ('0' <= str(idx) && str(idx) <= '7') { - if (strict) throw new InvalidEscapeException(str, cur) - val leadch = str(idx) - var oct = leadch - '0' - idx += 1 - if (idx < len && '0' <= str(idx) && str(idx) <= '7') { - oct = oct * 8 + str(idx) - '0' - idx += 1 - if (idx < len && leadch <= '3' && '0' <= str(idx) && str(idx) <= '7') { - oct = oct * 8 + str(idx) - '0' + // replace escapes with given first escape + def replace(first: Int): String = { + val b = new JLSBuilder + // append replacement starting at index `i`, with `next` backslash + @tailrec def loop(i: Int, next: Int): String = { + if (next >= 0) { + //require(str(next) == '\\') + if (next > i) b.append(str, i, next) + var idx = next + 1 + if (idx >= len) throw new InvalidEscapeException(str, next) + val c = str(idx) match { + case 'b' => '\b' + case 't' => '\t' + case 'n' => '\n' + case 'f' => '\f' + case 'r' => '\r' + case '"' => '"' + case '\'' => '\'' + case '\\' => '\\' + case o if '0' <= o && o <= '7' => + if (strict) throw new InvalidEscapeException(str, next) + val leadch = str(idx) + var oct = leadch - '0' idx += 1 - } + if (idx < len && '0' <= str(idx) && str(idx) <= '7') { + oct = oct * 8 + str(idx) - '0' + idx += 1 + if (idx < len && leadch <= '3' && '0' <= str(idx) && str(idx) <= '7') { + oct = oct * 8 + str(idx) - '0' + idx += 1 + } + } + idx -= 1 // retreat + oct.toChar + case _ => throw new InvalidEscapeException(str, next) } - output(oct.toChar) + idx += 1 // advance + b append c + loop(idx, str.indexOf('\\', idx)) } else { - val ch = str(idx) - idx += 1 - output { - ch match { - case 'b' => '\b' - case 't' => '\t' - case 'n' => '\n' - case 'f' => '\f' - case 'r' => '\r' - case '\"' => '\"' - case '\'' => '\'' - case '\\' => '\\' - case _ => throw new InvalidEscapeException(str, cur) - } - } + if (i < len) b.append(str, i, len) + b.toString } - } else { - idx += 1 } + loop(0, first) + } + str indexOf '\\' match { + case -1 => str + case i => replace(i) } - if (start == 0) str - else bldr.append(str, start, idx).toString } } diff --git a/test/junit/scala/StringContextTest.scala b/test/junit/scala/StringContextTest.scala new file mode 100644 index 000000000000..5abfe90cd159 --- /dev/null +++ b/test/junit/scala/StringContextTest.scala @@ -0,0 +1,51 @@ + +package scala + +import org.junit.Test +import org.junit.Assert._ +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 + +import scala.tools.testing.AssertUtil._ + +@RunWith(classOf[JUnit4]) +class StringContextTest { + + import StringContext._ + + @Test def noEscape() = { + val s = "string" + val res = processEscapes(s) + assertEquals(s, res) + } + @Test def tabbed() = { + val s = """a\tb""" + val res = processEscapes(s) + assertEquals("a\tb", res) + } + @Test def quoted() = { + val s = """hello, \"world\"""" + val res = processEscapes(s) + assertEquals("""hello, "world"""", res) + } + @Test def octal() = { + val s = """\123cala""" + val res = treatEscapes(s) + assertEquals("Scala", res) + } + @Test def doubled() = { + val s = """\123cala\123yntax""" + val res = treatEscapes(s) + assertEquals("ScalaSyntax", res) + } + @Test def badly() = assertThrows[InvalidEscapeException] { + val s = """Scala\""" + val res = treatEscapes(s) + assertEquals("Scala", res) + } + @Test def noOctal() = assertThrows[InvalidEscapeException] { + val s = """\123cala""" + val res = processEscapes(s) + assertEquals("Scala", res) + } +} From 9e1b464d44d2402211b905d6d89cf4004090fe43 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Sat, 10 May 2014 09:07:36 +0200 Subject: [PATCH 247/826] Allow tracing methods and classes in GenBCode --- .../tools/nsc/backend/jvm/AsmUtils.scala | 53 +++++++++++++++++++ .../nsc/backend/jvm/BCodeBodyBuilder.scala | 2 +- .../nsc/backend/jvm/BCodeSkelBuilder.scala | 9 ++++ .../nsc/backend/jvm/BytecodeWriters.scala | 2 +- .../tools/nsc/backend/jvm/GenBCode.scala | 11 ++++ 5 files changed, 75 insertions(+), 2 deletions(-) create mode 100644 src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala diff --git a/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala b/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala new file mode 100644 index 000000000000..856f85d9e3a6 --- /dev/null +++ b/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala @@ -0,0 +1,53 @@ +/* NSC -- new Scala compiler + * Copyright 2005-2014 LAMP/EPFL + * @author Martin Odersky + */ + +package scala.tools.nsc.backend.jvm + +import scala.tools.asm.tree.{ClassNode, MethodNode} +import java.io.PrintWriter +import scala.tools.asm.util.{TraceClassVisitor, TraceMethodVisitor, Textifier} + +object AsmUtils { + + /** + * Print the bytecode of methods generated by GenBCode to the standard output. Only methods + * whose name contains `traceMethodPattern` are traced. + */ + final val traceMethodEnabled = false + final val traceMethodPattern = "" + + /** + * Print the bytecode of classes generated by GenBCode to the standard output. + */ + final val traceClassEnabled = false + final val traceClassPattern = "" + + /** + * Print the bytedcode of classes as they are serialized by the ASM library. The serialization + * performed by `asm.ClassWriter` can change the code generated by GenBCode. For example, it + * introduces stack map frames, it computes the maximal stack sizes, and it replaces dead + * code by NOPs (see also https://github.com/scala/scala/pull/3726#issuecomment-42861780). + */ + final val traceSerializedClassEnabled = false + final val traceSerializedClassPattern = "" + + def traceMethod(mnode: MethodNode): Unit = { + println(s"Bytecode for method ${mnode.name}") + val p = new Textifier + val tracer = new TraceMethodVisitor(p) + mnode.accept(tracer) + val w = new PrintWriter(System.out) + p.print(w) + w.flush() + } + + def traceClass(cnode: ClassNode): Unit = { + println(s"Bytecode for class ${cnode.name}") + val w = new PrintWriter(System.out) + cnode.accept(new TraceClassVisitor(w)) + w.flush() + } + +} diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index 92ebe5027ac4..3d1b646069a2 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -808,7 +808,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { emit(asm.Opcodes.ATHROW) // ICode enters here into enterIgnoreMode, we'll rely instead on DCE at ClassNode level. } else if (from.isNullType) { bc drop from - mnode.visitInsn(asm.Opcodes.ACONST_NULL) + emit(asm.Opcodes.ACONST_NULL) } else (from, to) match { case (BYTE, LONG) | (SHORT, LONG) | (CHAR, LONG) | (INT, LONG) => bc.emitT2T(INT, LONG) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala index 360ce58ecc57..dae53bc0e525 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala @@ -14,6 +14,8 @@ import scala.tools.nsc.symtab._ import scala.annotation.switch import scala.tools.asm +import scala.tools.asm.util.{TraceMethodVisitor, ASMifier} +import java.io.PrintWriter /* * @@ -117,6 +119,9 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { gen(cd.impl) + if (AsmUtils.traceClassEnabled && cnode.name.contains(AsmUtils.traceClassPattern)) + AsmUtils.traceClass(cnode) + assert(cd.symbol == claszSymbol, "Someone messed up BCodePhase.claszSymbol during genPlainClass().") } // end of method genPlainClass() @@ -639,6 +644,10 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { // Note we don't invoke visitMax, thus there are no FrameNode among mnode.instructions. // The only non-instruction nodes to be found are LabelNode and LineNumberNode. } + + if (AsmUtils.traceMethodEnabled && mnode.name.contains(AsmUtils.traceMethodPattern)) + AsmUtils.traceMethod(mnode) + mnode = null } // end of method genDefDef() diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala b/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala index 8e6c09213fce..1d29fdee1070 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala @@ -1,6 +1,6 @@ /* NSC -- new Scala compiler * Copyright 2005-2013 LAMP/EPFL - * @author Paul Phillips + * @author Martin Odersky */ package scala.tools.nsc diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala index 193100474ccb..61cf76f524f5 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala @@ -243,6 +243,17 @@ abstract class GenBCode extends BCodeSyncAndTry { val plainC = SubItem3(plain.name, getByteArray(plain)) val beanC = if (bean == null) null else SubItem3(bean.name, getByteArray(bean)) + if (AsmUtils.traceSerializedClassEnabled && plain.name.contains(AsmUtils.traceSerializedClassPattern)) { + def readClass(bytes: Array[Byte]): asm.tree.ClassNode = { + val node = new asm.tree.ClassNode() + new asm.ClassReader(bytes).accept(node, 0) + node + } + if (mirrorC != null) AsmUtils.traceClass(readClass(mirrorC.jclassBytes)) + AsmUtils.traceClass(readClass(plainC.jclassBytes)) + if (beanC != null) AsmUtils.traceClass(readClass(beanC.jclassBytes)) + } + q3 add Item3(arrivalPos, mirrorC, plainC, beanC, outFolder) } From d430b03bc11c8fb279d9601fd33f5ac3ab48ed80 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 13 May 2014 15:13:39 +0200 Subject: [PATCH 248/826] Fix BeanInfo generation for GenBCode --- .../tools/nsc/backend/jvm/BCodeHelpers.scala | 2 +- test/files/jvm/beanInfo.check | 6 ++++++ test/files/jvm/beanInfo/C_1.scala | 9 +++++++++ test/files/jvm/beanInfo/Test_2.scala | 17 +++++++++++++++++ 4 files changed, 33 insertions(+), 1 deletion(-) create mode 100644 test/files/jvm/beanInfo.check create mode 100644 test/files/jvm/beanInfo/C_1.scala create mode 100644 test/files/jvm/beanInfo/Test_2.scala diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala index f800dbf9cd69..1ede91428806 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala @@ -1108,7 +1108,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { constructor.visitVarInsn(asm.Opcodes.ALOAD, 0) // push the class - constructor.visitLdcInsn(exemplar(cls).c) + constructor.visitLdcInsn(exemplar(cls).c.toASMType) // push the string array of field information constructor.visitLdcInsn(new java.lang.Integer(fieldList.length)) diff --git a/test/files/jvm/beanInfo.check b/test/files/jvm/beanInfo.check new file mode 100644 index 000000000000..d74e127711f0 --- /dev/null +++ b/test/files/jvm/beanInfo.check @@ -0,0 +1,6 @@ +property descriptors +x -- int -- public int p.C.x() -- null +y -- class java.lang.String -- public java.lang.String p.C.y() -- public void p.C.y_$eq(java.lang.String) +z -- class scala.collection.immutable.List -- public scala.collection.immutable.List p.C.z() -- public void p.C.z_$eq(scala.collection.immutable.List) +method descriptors +f -- public p.C p.C.f() diff --git a/test/files/jvm/beanInfo/C_1.scala b/test/files/jvm/beanInfo/C_1.scala new file mode 100644 index 000000000000..a338abea1d28 --- /dev/null +++ b/test/files/jvm/beanInfo/C_1.scala @@ -0,0 +1,9 @@ +package p + +@scala.beans.BeanInfo +class C { + val x: Int = 0 + var y: String = "" + var z: List[_] = Nil + def f: C = ??? +} diff --git a/test/files/jvm/beanInfo/Test_2.scala b/test/files/jvm/beanInfo/Test_2.scala new file mode 100644 index 000000000000..fa9b6e139129 --- /dev/null +++ b/test/files/jvm/beanInfo/Test_2.scala @@ -0,0 +1,17 @@ +object Test extends App { + val info = java.beans.Introspector.getBeanInfo(classOf[p.C]) + + println("property descriptors") + + val pds = info.getPropertyDescriptors + for (pd <- pds) { + println(s"${pd.getName} -- ${pd.getPropertyType} -- ${pd.getReadMethod} -- ${pd.getWriteMethod}") + } + + println("method descriptors") + + val mds = info.getMethodDescriptors + for (md <- mds) { + println(s"${md.getName} -- ${md.getMethod}") + } +} From e948073ae22167082ee672d8ac21507f7b3fa9f7 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 13 May 2014 12:31:26 +0200 Subject: [PATCH 249/826] SI-8582 emit InnerClasses attribute in GenBCode I removed the `-bcode` test since we have a build that passes `-Ybackend:GenBCode` to all tests. Short intro do the [`InnerClass` attribute][1]: - A class needs one `InnerClass` attribute for each of its nested classes - A class needs the `InnerClass` attribute for all (nested) classes that are mentioned in its constant pool The attribute for a nested class `A$B$C` consists of the long name of the outer class `A$B`, the short name of the inner class `C`, and an access flag set describig the visibility. The attribute seems to be used for reflection. [1]: http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.6 --- .../nsc/backend/jvm/BCodeSkelBuilder.scala | 3 +- test/files/run/t8582.check | 46 +++++++++++- test/files/run/t8582.scala | 71 ++++++++++++++++++- test/pending/run/t8582-bcode.check | 2 - test/pending/run/t8582-bcode.flags | 1 - test/pending/run/t8582-bcode.scala | 16 ----- 6 files changed, 114 insertions(+), 25 deletions(-) delete mode 100644 test/pending/run/t8582-bcode.check delete mode 100644 test/pending/run/t8582-bcode.flags delete mode 100644 test/pending/run/t8582-bcode.scala diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala index dae53bc0e525..ee9be5b11c69 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala @@ -116,12 +116,13 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { addClassFields() innerClassBufferASM ++= trackMemberClasses(claszSymbol, Nil) - gen(cd.impl) + addInnerClassesASM(cnode, innerClassBufferASM.toList) if (AsmUtils.traceClassEnabled && cnode.name.contains(AsmUtils.traceClassPattern)) AsmUtils.traceClass(cnode) + cnode.innerClasses assert(cd.symbol == claszSymbol, "Someone messed up BCodePhase.claszSymbol during genPlainClass().") } // end of method genPlainClass() diff --git a/test/files/run/t8582.check b/test/files/run/t8582.check index 7e9675698698..564f482ff87f 100644 --- a/test/files/run/t8582.check +++ b/test/files/run/t8582.check @@ -1,2 +1,44 @@ -class p1.p2.Singleton$Singleton$ -List(class p1.p2.Singleton$Singleton$Singleton$) +getClass on module gives module class + class p1.p2.Singleton$Singleton$ + +Nested module classes are found through reflection + p1.p2.Singleton$Singleton$: List(class p1.p2.Singleton$Singleton$Singleton$) + +Reflection can find direct nested classes (A1-B1-C1) + A1: List(class A1$B1) + A1$B1: List(class A1$B1$C1) + A1$B1$C1: List() + +Reflection can find direct nested classes (A2-B2-C2) + A2: List(class A2$B2) + A2$B2: List(class A2$B2$C2) + A2$B2$C2: List() + +Mirror classes have the same InnerClass attributes as the corresponding module class: + className[p1/p2/Singleton$Singleton$] outerClassName[p1/p2/Singleton] innerName[Singleton$] access[9] +Module class + className[p1/p2/Singleton$Singleton$] outerClassName[p1/p2/Singleton] innerName[Singleton$] access[9] + +An outer class has a InnerClass attribute for direct nested classes + className[A1$B1] outerClassName[A1] innerName[B1] access[1] +A nested class has an InnerClass attribute for itself (and also for its nested classes) + className[A1$B1] outerClassName[A1] innerName[B1] access[1] + className[A1$B1$C1] outerClassName[A1$B1] innerName[C1] access[1] +C1 is a nested class, so it has an InnerClass attribute for itself. +Because that attribute leads to an entry for B1 in the constant pool, C1 needs an InnerClass attribute for B1. + className[A1$B1] outerClassName[A1] innerName[B1] access[1] + className[A1$B1$C1] outerClassName[A1$B1] innerName[C1] access[1] + +The BeanInfo class has the same InnerClass attributes as the corresponding bean + className[A1$B1] outerClassName[A1] innerName[B1] access[1] + className[A1$B1$C1] outerClassName[A1$B1] innerName[C1] access[1] + +Class A2 mentions class C2 in the constant pool (due to method f), therefore it needs an InnerClass attribute for C1 + className[A2$B2] outerClassName[A2] innerName[B2] access[1] + className[A2$B2$C2] outerClassName[A2$B2] innerName[C2] access[1] +B2 + className[A2$B2] outerClassName[A2] innerName[B2] access[1] + className[A2$B2$C2] outerClassName[A2$B2] innerName[C2] access[1] +C2 + className[A2$B2] outerClassName[A2] innerName[B2] access[1] + className[A2$B2$C2] outerClassName[A2$B2] innerName[C2] access[1] diff --git a/test/files/run/t8582.scala b/test/files/run/t8582.scala index 844ab8ac1436..8a57ef795239 100644 --- a/test/files/run/t8582.scala +++ b/test/files/run/t8582.scala @@ -1,3 +1,6 @@ +import scala.tools.partest.BytecodeTest +import scala.collection.JavaConverters._ + package p1 { package p2 { object Singleton { @@ -8,9 +11,71 @@ package p1 { } } +class A1 { + class B1 { + @scala.beans.BeanInfo + class C1 + } +} + +class A2 { + class B2 { + class C2 + } + def f: B2#C2 = null +} + -object Test extends App { +object Test extends BytecodeTest { import p1.p2._ - println(Singleton.Singleton.getClass) - println(Singleton.Singleton.getClass.getDeclaredClasses.toList) + + def nested(c: Class[_]) = s" ${c.getName}: ${c.getDeclaredClasses.toList}" + + def nprintln(s: String) = println("\n"+s) + def printInner(cname: String): Unit = { + val cnode = loadClassNode(cname) + println(cnode.innerClasses.asScala.toList.map(i => s"className[${i.name}] outerClassName[${i.outerName}] innerName[${i.innerName}] access[${i.access}]").mkString(" ", "\n ", "")) + } + + def show() { + + println("getClass on module gives module class") + println(" " + Singleton.Singleton.getClass) + + nprintln("Nested module classes are found through reflection") + println(nested(Singleton.Singleton.getClass)) + + nprintln("Reflection can find direct nested classes (A1-B1-C1)") + println(nested(classOf[A1])) + println(nested(classOf[A1#B1])) + println(nested(classOf[A1#B1#C1])) + + nprintln("Reflection can find direct nested classes (A2-B2-C2)") + println(nested(classOf[A2])) + println(nested(classOf[A2#B2])) + println(nested(classOf[A2#B2#C2])) + + nprintln("Mirror classes have the same InnerClass attributes as the corresponding module class:") + printInner("p1.p2.Singleton") // mirror class + println("Module class") + printInner("p1.p2.Singleton$") + + nprintln("An outer class has a InnerClass attribute for direct nested classes") + printInner("A1") + println("A nested class has an InnerClass attribute for itself (and also for its nested classes)") + printInner("A1$B1") + println("C1 is a nested class, so it has an InnerClass attribute for itself.\n"+ + "Because that attribute leads to an entry for B1 in the constant pool, C1 needs an InnerClass attribute for B1.") + printInner("A1$B1$C1") + + nprintln("The BeanInfo class has the same InnerClass attributes as the corresponding bean") + printInner("A1$B1$C1BeanInfo") + + nprintln("Class A2 mentions class C2 in the constant pool (due to method f), therefore it needs an InnerClass attribute for C1") + printInner("A2") + println("B2") + printInner("A2$B2") + println("C2") + printInner("A2$B2$C2") + } } diff --git a/test/pending/run/t8582-bcode.check b/test/pending/run/t8582-bcode.check deleted file mode 100644 index 7e9675698698..000000000000 --- a/test/pending/run/t8582-bcode.check +++ /dev/null @@ -1,2 +0,0 @@ -class p1.p2.Singleton$Singleton$ -List(class p1.p2.Singleton$Singleton$Singleton$) diff --git a/test/pending/run/t8582-bcode.flags b/test/pending/run/t8582-bcode.flags deleted file mode 100644 index c30091d3de5d..000000000000 --- a/test/pending/run/t8582-bcode.flags +++ /dev/null @@ -1 +0,0 @@ --Ybackend:GenBCode diff --git a/test/pending/run/t8582-bcode.scala b/test/pending/run/t8582-bcode.scala deleted file mode 100644 index 844ab8ac1436..000000000000 --- a/test/pending/run/t8582-bcode.scala +++ /dev/null @@ -1,16 +0,0 @@ -package p1 { - package p2 { - object Singleton { - object Singleton { - object Singleton - } - } - } -} - - -object Test extends App { - import p1.p2._ - println(Singleton.Singleton.getClass) - println(Singleton.Singleton.getClass.getDeclaredClasses.toList) -} From fa2204e1749b21aa838350f321d5d85644be4ecf Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 13 May 2014 17:39:46 +0200 Subject: [PATCH 250/826] Move t8582 to test/files/jvm --- test/files/{run => jvm}/t8582.check | 0 test/files/{run => jvm}/t8582.scala | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename test/files/{run => jvm}/t8582.check (100%) rename test/files/{run => jvm}/t8582.scala (100%) diff --git a/test/files/run/t8582.check b/test/files/jvm/t8582.check similarity index 100% rename from test/files/run/t8582.check rename to test/files/jvm/t8582.check diff --git a/test/files/run/t8582.scala b/test/files/jvm/t8582.scala similarity index 100% rename from test/files/run/t8582.scala rename to test/files/jvm/t8582.scala From 8750592b5748be2be2e57912d13b349b2c1db103 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 13 May 2014 21:38:03 +0200 Subject: [PATCH 251/826] Deprecation of @BeanInfo --- src/library/scala/beans/BeanInfo.scala | 1 + test/files/neg/beanInfoDeprecation.check | 6 ++++++ test/files/neg/beanInfoDeprecation.flags | 1 + test/files/neg/beanInfoDeprecation.scala | 2 ++ 4 files changed, 10 insertions(+) create mode 100644 test/files/neg/beanInfoDeprecation.check create mode 100644 test/files/neg/beanInfoDeprecation.flags create mode 100644 test/files/neg/beanInfoDeprecation.scala diff --git a/src/library/scala/beans/BeanInfo.scala b/src/library/scala/beans/BeanInfo.scala index 799e93e71a87..d7f0a1618be7 100644 --- a/src/library/scala/beans/BeanInfo.scala +++ b/src/library/scala/beans/BeanInfo.scala @@ -17,4 +17,5 @@ package scala.beans * * @author Ross Judson (rjudson@managedobjects.com) */ +@deprecated(message = "the generation of BeanInfo classes is no longer supported", since = "2.12.0") class BeanInfo extends scala.annotation.Annotation diff --git a/test/files/neg/beanInfoDeprecation.check b/test/files/neg/beanInfoDeprecation.check new file mode 100644 index 000000000000..788b277818f0 --- /dev/null +++ b/test/files/neg/beanInfoDeprecation.check @@ -0,0 +1,6 @@ +beanInfoDeprecation.scala:2: warning: class BeanInfo in package beans is deprecated: the generation of BeanInfo classes is no longer supported +class C + ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found +one error found diff --git a/test/files/neg/beanInfoDeprecation.flags b/test/files/neg/beanInfoDeprecation.flags new file mode 100644 index 000000000000..c6bfaf1f64a4 --- /dev/null +++ b/test/files/neg/beanInfoDeprecation.flags @@ -0,0 +1 @@ +-deprecation -Xfatal-warnings diff --git a/test/files/neg/beanInfoDeprecation.scala b/test/files/neg/beanInfoDeprecation.scala new file mode 100644 index 000000000000..c7e3a86202d0 --- /dev/null +++ b/test/files/neg/beanInfoDeprecation.scala @@ -0,0 +1,2 @@ +@scala.beans.BeanInfo +class C From cb6546e1203218f3e0513fb07a2f7ea55f02a86a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Garillot?= Date: Mon, 27 Jan 2014 14:43:59 +0100 Subject: [PATCH 252/826] SI-8185 Correct grammar for single-warning compilation run --- src/compiler/scala/tools/nsc/Global.scala | 6 ++++-- test/files/jvm/deprecation.check | 2 +- test/files/jvm/future-spec.check | 2 +- test/files/jvm/interpreter.check | 4 ++-- test/files/jvm/serialization-new.check | 2 +- test/files/jvm/serialization.check | 2 +- test/files/neg/t5675.check | 2 +- test/files/run/collection-stacks.check | 2 +- test/files/run/colltest.check | 2 +- test/files/run/colltest1.scala | 2 +- test/files/run/compiler-asSeenFrom.scala | 2 +- test/files/run/constrained-types.check | 8 ++++---- test/files/run/delambdafy_t6028.check | 2 +- test/files/run/delay-bad.check | 2 +- test/files/run/eta-expand-star2.check | 2 +- test/files/run/existentials-in-compiler.scala | 2 +- test/files/run/inferred-type-constructors.check | 2 +- test/files/run/is-valid-num.scala | 2 +- test/files/run/iterator-from.scala | 2 +- test/files/run/literals.check | 2 +- test/files/run/mapConserve.scala | 2 +- test/files/run/names-defaults.check | 2 +- test/files/run/pc-conversions.scala | 2 +- test/files/run/reflection-java-annotations.check | 2 +- test/files/run/reflection-magicsymbols-repl.check | 2 +- test/files/run/repl-power.check | 4 ++-- test/files/run/richs.check | 2 +- test/files/run/stringinterpolation_macro-run.scala | 2 +- test/files/run/synchronized.check | 2 +- test/files/run/t2212.check | 2 +- test/files/run/t3361.check | 2 +- test/files/run/t3888.check | 2 +- test/files/run/t3970.check | 2 +- test/files/run/t3996.check | 2 +- test/files/run/t4080.check | 2 +- test/files/run/t4172.check | 2 +- test/files/run/t4396.check | 2 +- test/files/run/t4461.check | 2 +- test/files/run/t4594-repl-settings.scala | 2 +- test/files/run/t4680.check | 2 +- test/files/run/t4710.check | 2 +- test/files/run/t4813.check | 2 +- test/files/run/t5428.check | 2 +- test/files/run/t576.check | 2 +- test/files/run/t6028.check | 2 +- test/files/run/t6111.check | 2 +- test/files/run/t6292.check | 2 +- test/files/run/t6329_repl.check | 8 ++++---- test/files/run/t6329_repl_bug.check | 2 +- test/files/run/t6329_vanilla_bug.check | 2 +- test/files/run/t6481.check | 2 +- test/files/run/t6690.check | 2 +- test/files/run/t6863.check | 2 +- test/files/run/t6935.check | 2 +- test/files/run/t7096.scala | 2 +- test/files/run/t7319.check | 6 +++--- test/files/run/t7582.check | 2 +- test/files/run/t7582b.check | 2 +- test/files/run/t7932.check | 2 +- test/files/run/t8196.check | 2 +- test/files/run/t8549.check | 2 +- test/files/run/unittest_collection.check | 2 +- 62 files changed, 75 insertions(+), 73 deletions(-) diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 35eab9433396..cb785de4b39e 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -1169,8 +1169,10 @@ class Global(var currentSettings: Settings, var reporter: Reporter) if (option) reporter.warning(pos, msg) else if (!(warnings contains pos)) warnings += ((pos, msg)) def summarize() = - if (warnings.nonEmpty && (option.isDefault || settings.fatalWarnings)) - warning("there were %d %s warning(s); re-run with %s for details".format(warnings.size, what, option.name)) + if (warnings.nonEmpty && (option.isDefault || settings.fatalWarnings)){ + val warningEvent = if (warnings.size > 1) s"were ${ warnings.size } $what warnings" else s"was one $what warning" + warning(s"there $warningEvent; re-run with ${ option.name } for details") + } } def newSourceFile(code: String, filename: String = "") = diff --git a/test/files/jvm/deprecation.check b/test/files/jvm/deprecation.check index d116778d3f35..3c27d4d08201 100644 --- a/test/files/jvm/deprecation.check +++ b/test/files/jvm/deprecation.check @@ -1,3 +1,3 @@ -warning: there were 4 deprecation warning(s); re-run with -deprecation for details +warning: there were 4 deprecation warnings; re-run with -deprecation for details Note: deprecation/Use_2.java uses or overrides a deprecated API. Note: Recompile with -Xlint:deprecation for details. diff --git a/test/files/jvm/future-spec.check b/test/files/jvm/future-spec.check index 844ca5468251..df1629dd7eb1 100644 --- a/test/files/jvm/future-spec.check +++ b/test/files/jvm/future-spec.check @@ -1 +1 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details diff --git a/test/files/jvm/interpreter.check b/test/files/jvm/interpreter.check index b55ecc10e680..d124794e72ae 100644 --- a/test/files/jvm/interpreter.check +++ b/test/files/jvm/interpreter.check @@ -95,7 +95,7 @@ scala> case class Bar(n: Int) defined class Bar scala> implicit def foo2bar(foo: Foo) = Bar(foo.n) -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details foo2bar: (foo: Foo)Bar scala> val bar: Bar = Foo(3) @@ -269,7 +269,7 @@ scala> xs map (x => x) res6: Array[_] = Array(1, 2) scala> xs map (x => (x, x)) -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details res7: Array[(_$1, _$1)] forSome { type _$1 } = Array((1,1), (2,2)) scala> diff --git a/test/files/jvm/serialization-new.check b/test/files/jvm/serialization-new.check index 47d7bfd9204a..8ec5754ea2fc 100644 --- a/test/files/jvm/serialization-new.check +++ b/test/files/jvm/serialization-new.check @@ -1,4 +1,4 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were 2 deprecation warnings; re-run with -deprecation for details a1 = Array[1,2,3] _a1 = Array[1,2,3] arrayEquals(a1, _a1): true diff --git a/test/files/jvm/serialization.check b/test/files/jvm/serialization.check index 47d7bfd9204a..8ec5754ea2fc 100644 --- a/test/files/jvm/serialization.check +++ b/test/files/jvm/serialization.check @@ -1,4 +1,4 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were 2 deprecation warnings; re-run with -deprecation for details a1 = Array[1,2,3] _a1 = Array[1,2,3] arrayEquals(a1, _a1): true diff --git a/test/files/neg/t5675.check b/test/files/neg/t5675.check index da608a2b78bc..13226935dcc8 100644 --- a/test/files/neg/t5675.check +++ b/test/files/neg/t5675.check @@ -1,2 +1,2 @@ -error: there were 1 feature warning(s); re-run with -feature for details +error: there was one feature warning; re-run with -feature for details one error found diff --git a/test/files/run/collection-stacks.check b/test/files/run/collection-stacks.check index 895bde374de8..3a366bfcdfd9 100644 --- a/test/files/run/collection-stacks.check +++ b/test/files/run/collection-stacks.check @@ -1,4 +1,4 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details 3-2-1: true 3-2-1: true apply diff --git a/test/files/run/colltest.check b/test/files/run/colltest.check index 1e850bb582a4..46e4017eb6df 100644 --- a/test/files/run/colltest.check +++ b/test/files/run/colltest.check @@ -1,4 +1,4 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were 2 deprecation warnings; re-run with -deprecation for details true false true diff --git a/test/files/run/colltest1.scala b/test/files/run/colltest1.scala index 8dce69afc994..e0ec378585f5 100644 --- a/test/files/run/colltest1.scala +++ b/test/files/run/colltest1.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warnings; re-run with -Yinline-warnings for details */ import scala.collection._ import scala.language.postfixOps diff --git a/test/files/run/compiler-asSeenFrom.scala b/test/files/run/compiler-asSeenFrom.scala index ea96c6fba797..677dd40ddc4a 100644 --- a/test/files/run/compiler-asSeenFrom.scala +++ b/test/files/run/compiler-asSeenFrom.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warning; re-run with -Yinline-warnings for details */ import scala.tools.nsc._ import scala.tools.partest.DirectTest diff --git a/test/files/run/constrained-types.check b/test/files/run/constrained-types.check index 9a106785a1ef..a3cd59b9fbde 100644 --- a/test/files/run/constrained-types.check +++ b/test/files/run/constrained-types.check @@ -71,11 +71,11 @@ scala> var four = "four" four: String = four scala> val four2 = m(four) // should have an existential bound -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details four2: String @Annot(x) forSome { val x: String } = four scala> val four3 = four2 // should have the same type as four2 -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details four3: String @Annot(x) forSome { val x: String } = four scala> val stuff = m("stuff") // should not crash @@ -98,7 +98,7 @@ scala> def m = { val y : String @Annot(x) = x y } // x should not escape the local scope with a narrow type -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details m: String @Annot(x) forSome { val x: String } scala> @@ -112,7 +112,7 @@ scala> def n(y: String) = { } m("stuff".stripMargin) } // x should be existentially bound -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details n: (y: String)String @Annot(x) forSome { val x: String } scala> diff --git a/test/files/run/delambdafy_t6028.check b/test/files/run/delambdafy_t6028.check index 92cfbaefb66b..7bd8cd720232 100644 --- a/test/files/run/delambdafy_t6028.check +++ b/test/files/run/delambdafy_t6028.check @@ -54,4 +54,4 @@ package { } } -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details diff --git a/test/files/run/delay-bad.check b/test/files/run/delay-bad.check index 5d8c5fa1d48f..cb6e329f7ac8 100644 --- a/test/files/run/delay-bad.check +++ b/test/files/run/delay-bad.check @@ -4,7 +4,7 @@ delay-bad.scala:53: warning: a pure expression does nothing in statement positio delay-bad.scala:73: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses f(new { val x = 5 } with E() { 5 }) ^ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details // new C { } diff --git a/test/files/run/eta-expand-star2.check b/test/files/run/eta-expand-star2.check index cbf47812553a..d6929e4969d0 100644 --- a/test/files/run/eta-expand-star2.check +++ b/test/files/run/eta-expand-star2.check @@ -1,2 +1,2 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details hello diff --git a/test/files/run/existentials-in-compiler.scala b/test/files/run/existentials-in-compiler.scala index d019d56b42fc..dfc7048b313f 100644 --- a/test/files/run/existentials-in-compiler.scala +++ b/test/files/run/existentials-in-compiler.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warnings; re-run with -Yinline-warnings for details */ import scala.tools.nsc._ import scala.tools.partest.CompilerTest diff --git a/test/files/run/inferred-type-constructors.check b/test/files/run/inferred-type-constructors.check index 5992ef02ad33..67075a59a9e6 100644 --- a/test/files/run/inferred-type-constructors.check +++ b/test/files/run/inferred-type-constructors.check @@ -1,4 +1,4 @@ -warning: there were 2 feature warning(s); re-run with -feature for details +warning: there were 2 feature warnings; re-run with -feature for details p.Iterable[Int] p.Set[Int] p.Seq[Int] diff --git a/test/files/run/is-valid-num.scala b/test/files/run/is-valid-num.scala index 65e8ceeca678..4ab2fac8dd2a 100644 --- a/test/files/run/is-valid-num.scala +++ b/test/files/run/is-valid-num.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warnings; re-run with -Yinline-warnings for details */ object Test { def x = BigInt("10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000") diff --git a/test/files/run/iterator-from.scala b/test/files/run/iterator-from.scala index 269e8596578b..e2ca5864eab6 100644 --- a/test/files/run/iterator-from.scala +++ b/test/files/run/iterator-from.scala @@ -1,5 +1,5 @@ /* This file tests iteratorFrom, keysIteratorFrom, and valueIteratorFrom on various sorted sets and maps - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warnings; re-run with -Yinline-warnings for details */ import scala.util.{Random => R} diff --git a/test/files/run/literals.check b/test/files/run/literals.check index ed7c6ca5b3c4..62c5fd68ae86 100644 --- a/test/files/run/literals.check +++ b/test/files/run/literals.check @@ -1,4 +1,4 @@ -warning: there were 5 deprecation warning(s); re-run with -deprecation for details +warning: there were 5 deprecation warnings; re-run with -deprecation for details test '\u0024' == '$' was successful test '\u005f' == '_' was successful test 65.asInstanceOf[Char] == 'A' was successful diff --git a/test/files/run/mapConserve.scala b/test/files/run/mapConserve.scala index d1d52f3107bb..f52af3b9f4c3 100644 --- a/test/files/run/mapConserve.scala +++ b/test/files/run/mapConserve.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warnings; re-run with -Yinline-warnings for details */ import scala.annotation.tailrec import scala.collection.mutable.ListBuffer diff --git a/test/files/run/names-defaults.check b/test/files/run/names-defaults.check index 0037822f3b1c..97cfa4e52030 100644 --- a/test/files/run/names-defaults.check +++ b/test/files/run/names-defaults.check @@ -1,7 +1,7 @@ names-defaults.scala:269: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses spawn(b = { val ttt = 1; ttt }, a = 0) ^ -warning: there were 4 deprecation warning(s); re-run with -deprecation for details +warning: there were 4 deprecation warnings; re-run with -deprecation for details 1: @ get: $ get: 2 diff --git a/test/files/run/pc-conversions.scala b/test/files/run/pc-conversions.scala index 19fef355c88f..5fecac9d9456 100644 --- a/test/files/run/pc-conversions.scala +++ b/test/files/run/pc-conversions.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warning; re-run with -Yinline-warnings for details */ import collection._ diff --git a/test/files/run/reflection-java-annotations.check b/test/files/run/reflection-java-annotations.check index 72d40989febd..842037254ef8 100644 --- a/test/files/run/reflection-java-annotations.check +++ b/test/files/run/reflection-java-annotations.check @@ -1,4 +1,4 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details List(JavaComplexAnnotation_1(v1 = 1, v10 = "hello", v101 = [101, 101], v102 = [102, 102], v103 = ['g', 'g'], v104 = [104, 104], v105 = [105L, 105L], v106 = [106.0, 106.0], v107 = [107.0, 107.0], v108 = [false, true], v11 = classOf[JavaAnnottee_1], v110 = ["hello", "world"], v111 = [classOf[JavaSimpleAnnotation_1], classOf[JavaComplexAnnotation_1]], v112 = [FOO, BAR], v113 = [JavaSimpleAnnotation_1(v1 = 21, v10 = "world2", v11 = classOf[JavaComplexAnnotation_1], v12 = BAR, v2 = 22, v3 = '\027', v4 = 24, v5 = 25L, v6 = 26.0, v7 = 27.0, v8 = false)], v12 = FOO, v13 = JavaSimpleAnnotation_1(v1 = 11, v10 = "world1", v11 = classOf[JavaSimpleAnnotation_1], v12 = FOO, v2 = 12, v3 = '\r', v4 = 14, v5 = 15L, v6 = 16.0, v7 = 17.0, v8 = false), v2 = 2, v3 = '\03', v4 = 4, v5 = 5L, v6 = 6.0, v7 = 7.0, v8 = false)) ======= new JavaComplexAnnotation_1(v1 = 1, v10 = "hello", v101 = Array(101, 101), v102 = Array(102, 102), v103 = Array('g', 'g'), v104 = Array(104, 104), v105 = Array(105L, 105L), v106 = Array(106.0, 106.0), v107 = Array(107.0, 107.0), v108 = Array(false, true), v11 = classOf[JavaAnnottee_1], v110 = Array("hello", "world"), v111 = Array(classOf[JavaSimpleAnnotation_1], classOf[JavaComplexAnnotation_1]), v112 = Array(FOO, BAR), v113 = Array(new JavaSimpleAnnotation_1(v1 = 21, v10 = "world2", v11 = classOf[JavaComplexAnnotation_1], v12 = BAR, v2 = 22, v3 = '\027', v4 = 24, v5 = 25L, v6 = 26.0, v7 = 27.0, v8 = false)), v12 = FOO, v13 = new JavaSimpleAnnotation_1(v1 = 11, v10 = "world1", v11 = classOf[JavaSimpleAnnotation_1], v12 = FOO, v2 = 12, v3 = '\r', v4 = 14, v5 = 15L, v6 = 16.0, v7 = 17.0, v8 = false), v2 = 2, v3 = '\03', v4 = 4, v5 = 5L, v6 = 6.0, v7 = 7.0, v8 = false) diff --git a/test/files/run/reflection-magicsymbols-repl.check b/test/files/run/reflection-magicsymbols-repl.check index a1bee766522c..72aef1d3be6b 100644 --- a/test/files/run/reflection-magicsymbols-repl.check +++ b/test/files/run/reflection-magicsymbols-repl.check @@ -21,7 +21,7 @@ scala> def test(n: Int): Unit = { val x = sig.asInstanceOf[MethodType].params.head println(x.info) } -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details test: (n: Int)Unit scala> for (i <- 1 to 8) test(i) diff --git a/test/files/run/repl-power.check b/test/files/run/repl-power.check index e56901e0f288..8a8ca4601227 100644 --- a/test/files/run/repl-power.check +++ b/test/files/run/repl-power.check @@ -11,11 +11,11 @@ scala> :power scala> // guarding against "error: reference to global is ambiguous" scala> global.emptyValDef // "it is imported twice in the same scope by ..." -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details res0: $r.global.noSelfType.type = private val _ = _ scala> val tp = ArrayClass[scala.util.Random] // magic with tags -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details tp: $r.global.Type = Array[scala.util.Random] scala> tp.memberType(Array_apply) // evidence diff --git a/test/files/run/richs.check b/test/files/run/richs.check index 02a98b376d0c..bcaf8bdb8d03 100644 --- a/test/files/run/richs.check +++ b/test/files/run/richs.check @@ -1,4 +1,4 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were 2 deprecation warnings; re-run with -deprecation for details RichCharTest1: true diff --git a/test/files/run/stringinterpolation_macro-run.scala b/test/files/run/stringinterpolation_macro-run.scala index ff779dd1d332..a6def9854090 100644 --- a/test/files/run/stringinterpolation_macro-run.scala +++ b/test/files/run/stringinterpolation_macro-run.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warnings; re-run with -Yinline-warnings for details */ object Test extends App { diff --git a/test/files/run/synchronized.check b/test/files/run/synchronized.check index 6e99739633fb..eab191b4ed5e 100644 --- a/test/files/run/synchronized.check +++ b/test/files/run/synchronized.check @@ -1,4 +1,4 @@ -warning: there were 14 inliner warning(s); re-run with -Yinline-warnings for details +warning: there were 14 inliner warnings; re-run with -Yinline-warnings for details .|. c1.f1: OK .|. c1.fi: OK .|... c1.fv: OK diff --git a/test/files/run/t2212.check b/test/files/run/t2212.check index 8ab4d60ab3e7..f7e80439c7bf 100644 --- a/test/files/run/t2212.check +++ b/test/files/run/t2212.check @@ -1,4 +1,4 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were 2 deprecation warnings; re-run with -deprecation for details LinkedList(1) LinkedList(1) true diff --git a/test/files/run/t3361.check b/test/files/run/t3361.check index c18bdc9aff66..5e0a76350199 100644 --- a/test/files/run/t3361.check +++ b/test/files/run/t3361.check @@ -1 +1 @@ -warning: there were 16 deprecation warning(s); re-run with -deprecation for details +warning: there were 16 deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t3888.check b/test/files/run/t3888.check index 844ca5468251..df1629dd7eb1 100644 --- a/test/files/run/t3888.check +++ b/test/files/run/t3888.check @@ -1 +1 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details diff --git a/test/files/run/t3970.check b/test/files/run/t3970.check index bd89fff9d935..0683a6c1a689 100644 --- a/test/files/run/t3970.check +++ b/test/files/run/t3970.check @@ -1 +1 @@ -warning: there were 5 deprecation warning(s); re-run with -deprecation for details +warning: there were 5 deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t3996.check b/test/files/run/t3996.check index a92ddc0e512a..2e8e558f8896 100644 --- a/test/files/run/t3996.check +++ b/test/files/run/t3996.check @@ -1 +1 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were 2 deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t4080.check b/test/files/run/t4080.check index 1953a68ad386..c642cc67daf5 100644 --- a/test/files/run/t4080.check +++ b/test/files/run/t4080.check @@ -1,2 +1,2 @@ -warning: there were 3 deprecation warning(s); re-run with -deprecation for details +warning: there were 3 deprecation warnings; re-run with -deprecation for details LinkedList(1, 0, 2, 3) diff --git a/test/files/run/t4172.check b/test/files/run/t4172.check index d94638d27e1d..a748430e2ee3 100644 --- a/test/files/run/t4172.check +++ b/test/files/run/t4172.check @@ -2,7 +2,7 @@ Type in expressions to have them evaluated. Type :help for more information. scala> val c = { class C { override def toString = "C" }; ((new C, new C { def f = 2 })) } -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details c: (C, C{def f: Int}) forSome { type C <: AnyRef } = (C,C) scala> diff --git a/test/files/run/t4396.check b/test/files/run/t4396.check index a75e1f257f55..d38fb7fae7ec 100644 --- a/test/files/run/t4396.check +++ b/test/files/run/t4396.check @@ -1,4 +1,4 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details hallo constructor out:22 diff --git a/test/files/run/t4461.check b/test/files/run/t4461.check index 94886693246c..c44b0fc07746 100644 --- a/test/files/run/t4461.check +++ b/test/files/run/t4461.check @@ -1,4 +1,4 @@ -warning: there were 4 deprecation warning(s); re-run with -deprecation for details +warning: there were 4 deprecation warnings; re-run with -deprecation for details Include(End,1) Include(End,2) Include(End,3) diff --git a/test/files/run/t4594-repl-settings.scala b/test/files/run/t4594-repl-settings.scala index d2335460e59a..8b8b2e3746eb 100644 --- a/test/files/run/t4594-repl-settings.scala +++ b/test/files/run/t4594-repl-settings.scala @@ -11,7 +11,7 @@ object Test extends SessionTest { |depp: String | |scala> def a = depp - |warning: there were 1 deprecation warning(s); re-run with -deprecation for details + |warning: there was one deprecation warning; re-run with -deprecation for details |a: String | |scala> :settings +deprecation diff --git a/test/files/run/t4680.check b/test/files/run/t4680.check index 512bfd4b54b2..21a1e0cd1505 100644 --- a/test/files/run/t4680.check +++ b/test/files/run/t4680.check @@ -4,7 +4,7 @@ t4680.scala:51: warning: a pure expression does nothing in statement position; y t4680.scala:69: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses new { val x = 5 } with E() { 5 } ^ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details // new C { } diff --git a/test/files/run/t4710.check b/test/files/run/t4710.check index f2335d1bdd8e..6ee7198b4b5a 100644 --- a/test/files/run/t4710.check +++ b/test/files/run/t4710.check @@ -2,7 +2,7 @@ Type in expressions to have them evaluated. Type :help for more information. scala> def method : String = { implicit def f(s: Symbol) = "" ; 'symbol } -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details method: String scala> diff --git a/test/files/run/t4813.check b/test/files/run/t4813.check index a92ddc0e512a..2e8e558f8896 100644 --- a/test/files/run/t4813.check +++ b/test/files/run/t4813.check @@ -1 +1 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were 2 deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t5428.check b/test/files/run/t5428.check index a46514ae7ceb..52fce0939968 100644 --- a/test/files/run/t5428.check +++ b/test/files/run/t5428.check @@ -1,2 +1,2 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details Stack(8, 7, 6, 5, 4, 3) diff --git a/test/files/run/t576.check b/test/files/run/t576.check index 6458d5d7436f..22f3843abfea 100644 --- a/test/files/run/t576.check +++ b/test/files/run/t576.check @@ -1,4 +1,4 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details 1 2 3 diff --git a/test/files/run/t6028.check b/test/files/run/t6028.check index a6c4db8f115a..55ff42d8d7e2 100644 --- a/test/files/run/t6028.check +++ b/test/files/run/t6028.check @@ -81,4 +81,4 @@ package { } } -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details diff --git a/test/files/run/t6111.check b/test/files/run/t6111.check index 1f23a87f730d..21a5b19ea09a 100644 --- a/test/files/run/t6111.check +++ b/test/files/run/t6111.check @@ -1,3 +1,3 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were 2 deprecation warnings; re-run with -deprecation for details (8,8) (x,x) diff --git a/test/files/run/t6292.check b/test/files/run/t6292.check index 6232ba75191b..6f7430d5b866 100644 --- a/test/files/run/t6292.check +++ b/test/files/run/t6292.check @@ -1 +1 @@ -warning: there were 7 deprecation warning(s); re-run with -deprecation for details +warning: there were 7 deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t6329_repl.check b/test/files/run/t6329_repl.check index 5049426ab456..ad0bb46e5bc5 100644 --- a/test/files/run/t6329_repl.check +++ b/test/files/run/t6329_repl.check @@ -5,28 +5,28 @@ scala> import scala.reflect.classTag import scala.reflect.classTag scala> classManifest[scala.List[_]] -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details res0: scala.reflect.ClassTag[List[_]] = scala.collection.immutable.List[] scala> classTag[scala.List[_]] res1: scala.reflect.ClassTag[List[_]] = scala.collection.immutable.List scala> classManifest[scala.collection.immutable.List[_]] -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details res2: scala.reflect.ClassTag[List[_]] = scala.collection.immutable.List[] scala> classTag[scala.collection.immutable.List[_]] res3: scala.reflect.ClassTag[List[_]] = scala.collection.immutable.List scala> classManifest[Predef.Set[_]] -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details res4: scala.reflect.ClassTag[scala.collection.immutable.Set[_]] = scala.collection.immutable.Set[] scala> classTag[Predef.Set[_]] res5: scala.reflect.ClassTag[scala.collection.immutable.Set[_]] = scala.collection.immutable.Set scala> classManifest[scala.collection.immutable.Set[_]] -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details res6: scala.reflect.ClassTag[scala.collection.immutable.Set[_]] = scala.collection.immutable.Set[] scala> classTag[scala.collection.immutable.Set[_]] diff --git a/test/files/run/t6329_repl_bug.check b/test/files/run/t6329_repl_bug.check index 44c41cfd0354..38a8de56065c 100644 --- a/test/files/run/t6329_repl_bug.check +++ b/test/files/run/t6329_repl_bug.check @@ -8,7 +8,7 @@ scala> import scala.reflect.runtime._ import scala.reflect.runtime._ scala> classManifest[List[_]] -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details res0: scala.reflect.ClassTag[List[_]] = scala.collection.immutable.List[] scala> scala.reflect.classTag[List[_]] diff --git a/test/files/run/t6329_vanilla_bug.check b/test/files/run/t6329_vanilla_bug.check index 640d168a8a82..01bf0636ea13 100644 --- a/test/files/run/t6329_vanilla_bug.check +++ b/test/files/run/t6329_vanilla_bug.check @@ -1,3 +1,3 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details scala.collection.immutable.List[] scala.collection.immutable.List diff --git a/test/files/run/t6481.check b/test/files/run/t6481.check index df4072224284..4a3f6f7ee944 100644 --- a/test/files/run/t6481.check +++ b/test/files/run/t6481.check @@ -1,4 +1,4 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details delayed init new foo(1, 2) delayed init diff --git a/test/files/run/t6690.check b/test/files/run/t6690.check index a92ddc0e512a..2e8e558f8896 100644 --- a/test/files/run/t6690.check +++ b/test/files/run/t6690.check @@ -1 +1 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were 2 deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t6863.check b/test/files/run/t6863.check index fea22b582f0b..37de2e6e51a0 100644 --- a/test/files/run/t6863.check +++ b/test/files/run/t6863.check @@ -10,4 +10,4 @@ t6863.scala:46: warning: comparing values of types Unit and Unit using `==' will t6863.scala:59: warning: comparing values of types Unit and Unit using `==' will always yield true assert({ () => x }.apply == ()) ^ -warning: there were 4 deprecation warning(s); re-run with -deprecation for details +warning: there were 4 deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t6935.check b/test/files/run/t6935.check index 844ca5468251..df1629dd7eb1 100644 --- a/test/files/run/t6935.check +++ b/test/files/run/t6935.check @@ -1 +1 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details diff --git a/test/files/run/t7096.scala b/test/files/run/t7096.scala index e7a894fc2341..872562dd4d21 100644 --- a/test/files/run/t7096.scala +++ b/test/files/run/t7096.scala @@ -1,5 +1,5 @@ /* - * filter: inliner warning\(s\); re-run with -Yinline-warnings for details + * filter: inliner warning; re-run with -Yinline-warnings for details */ import scala.tools.partest._ import scala.tools.nsc._ diff --git a/test/files/run/t7319.check b/test/files/run/t7319.check index b7443aa0c400..2ac414209865 100644 --- a/test/files/run/t7319.check +++ b/test/files/run/t7319.check @@ -5,15 +5,15 @@ scala> class M[A] defined class M scala> implicit def ma0[A](a: A): M[A] = null -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details ma0: [A](a: A)M[A] scala> implicit def ma1[A](a: A): M[A] = null -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details ma1: [A](a: A)M[A] scala> def convert[F[X <: F[X]]](builder: F[_ <: F[_]]) = 0 -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details convert: [F[X <: F[X]]](builder: F[_ <: F[_]])Int scala> convert(Some[Int](0)) diff --git a/test/files/run/t7582.check b/test/files/run/t7582.check index 225fb1ace851..cd951d8d4f62 100644 --- a/test/files/run/t7582.check +++ b/test/files/run/t7582.check @@ -1,2 +1,2 @@ -warning: there were 1 inliner warning(s); re-run with -Yinline-warnings for details +warning: there was one inliner warning; re-run with -Yinline-warnings for details 2 diff --git a/test/files/run/t7582b.check b/test/files/run/t7582b.check index 225fb1ace851..cd951d8d4f62 100644 --- a/test/files/run/t7582b.check +++ b/test/files/run/t7582b.check @@ -1,2 +1,2 @@ -warning: there were 1 inliner warning(s); re-run with -Yinline-warnings for details +warning: there was one inliner warning; re-run with -Yinline-warnings for details 2 diff --git a/test/files/run/t7932.check b/test/files/run/t7932.check index 13d64f1d3c5e..3f0a0c4f6271 100644 --- a/test/files/run/t7932.check +++ b/test/files/run/t7932.check @@ -1,3 +1,3 @@ -warning: there were 1 feature warning(s); re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details public Category C.category() public Category C.category1() diff --git a/test/files/run/t8196.check b/test/files/run/t8196.check index b32f42cf0783..f021a3619fd6 100644 --- a/test/files/run/t8196.check +++ b/test/files/run/t8196.check @@ -1,7 +1,7 @@ t8196.scala:26: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses form2.g1 // comment this line in order to make the test pass ^ -warning: there were 2 feature warning(s); re-run with -feature for details +warning: there were 2 feature warnings; re-run with -feature for details Scope{ final private val f1: Int } diff --git a/test/files/run/t8549.check b/test/files/run/t8549.check index a92ddc0e512a..2e8e558f8896 100644 --- a/test/files/run/t8549.check +++ b/test/files/run/t8549.check @@ -1 +1 @@ -warning: there were 2 deprecation warning(s); re-run with -deprecation for details +warning: there were 2 deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/unittest_collection.check b/test/files/run/unittest_collection.check index 844ca5468251..df1629dd7eb1 100644 --- a/test/files/run/unittest_collection.check +++ b/test/files/run/unittest_collection.check @@ -1 +1 @@ -warning: there were 1 deprecation warning(s); re-run with -deprecation for details +warning: there was one deprecation warning; re-run with -deprecation for details From d7aec58bf3dfbe57c29ad29e7035a6a351620423 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Wed, 14 May 2014 15:02:07 +0200 Subject: [PATCH 253/826] SI-8587 Explicitly document forall/exists for empty collections This behaviour isn't always intuitive for newcomers. Also changes inadvertant doc comment to an impl. comment. --- src/library/scala/collection/TraversableLike.scala | 8 ++++---- src/library/scala/collection/TraversableOnce.scala | 7 +++---- 2 files changed, 7 insertions(+), 8 deletions(-) diff --git a/src/library/scala/collection/TraversableLike.scala b/src/library/scala/collection/TraversableLike.scala index b60ea86ab069..d3a7db6968ea 100644 --- a/src/library/scala/collection/TraversableLike.scala +++ b/src/library/scala/collection/TraversableLike.scala @@ -345,8 +345,8 @@ trait TraversableLike[+A, +Repr] extends Any * $mayNotTerminateInf * * @param p the predicate used to test elements. - * @return `true` if the given predicate `p` holds for all elements - * of this $coll, otherwise `false`. + * @return `true` if this $coll is empty, otherwise `true` if the given predicate `p` + * holds for all elements of this $coll, otherwise `false`. */ def forall(p: A => Boolean): Boolean = { var result = true @@ -362,8 +362,8 @@ trait TraversableLike[+A, +Repr] extends Any * $mayNotTerminateInf * * @param p the predicate used to test elements. - * @return `true` if the given predicate `p` holds for some of the - * elements of this $coll, otherwise `false`. + * @return `false` if this $coll is empty, otherwise `true` if the given predicate `p` + * holds for some of the elements of this $coll, otherwise `false` */ def exists(p: A => Boolean): Boolean = { var result = false diff --git a/src/library/scala/collection/TraversableOnce.scala b/src/library/scala/collection/TraversableOnce.scala index 072fd3da44b3..a8c4e047ab05 100644 --- a/src/library/scala/collection/TraversableOnce.scala +++ b/src/library/scala/collection/TraversableOnce.scala @@ -85,10 +85,9 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] { */ def seq: TraversableOnce[A] - /** Presently these are abstract because the Traversable versions use - * breakable/break, and I wasn't sure enough of how that's supposed to - * function to consolidate them with the Iterator versions. - */ + // Presently these are abstract because the Traversable versions use + // breakable/break, and I wasn't sure enough of how that's supposed to + // function to consolidate them with the Iterator versions. def forall(p: A => Boolean): Boolean def exists(p: A => Boolean): Boolean def find(p: A => Boolean): Option[A] From a670475b6a949d427c7166d429c76bfbbc1ae697 Mon Sep 17 00:00:00 2001 From: Marcin Kubala Date: Fri, 16 May 2014 14:50:28 +0200 Subject: [PATCH 254/826] SI-8591 Scaladoc: Problem with scrolling under Safari on iOS --- src/scaladoc/scala/tools/nsc/doc/html/resource/lib/index.css | 1 + 1 file changed, 1 insertion(+) diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/index.css b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/index.css index 55fb370a414c..3e352a95b3a9 100644 --- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/index.css +++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/index.css @@ -310,6 +310,7 @@ h1 { position: fixed; margin-left: 300px; display: block; + -webkit-overflow-scrolling: touch; } #content > iframe { From f9abdcef6c9b8d96e1aaf98942938e2e875285d0 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sat, 10 May 2014 10:49:36 +0200 Subject: [PATCH 255/826] SI-8574 Copy @SerialVersionUID, etc, to specialized subclasses The test case demonstrates that this is important for serialization and for strictfp. (Although the latter is still pretty broken, see SI-7954.) Now that the synthetic subclass of `Tuple2[Int, Int]` also has the `@deprecatedInheritance` annotation, I had to change the spot that issues this warning to be silent after the typer phase. Otherwise, we get two warnings in `run/t3888.scala`. This also remedies double warnings that were incurred in `neg/t6162-inheritance`. --- .../tools/nsc/transform/SpecializeTypes.scala | 1 + .../scala/tools/nsc/typechecker/Typers.scala | 2 +- test/files/neg/t6162-inheritance.check | 8 +----- test/files/run/t8574.scala | 27 +++++++++++++++++++ 4 files changed, 30 insertions(+), 8 deletions(-) create mode 100644 test/files/run/t8574.scala diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala index 02e55241b314..908aa69310d8 100644 --- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala +++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala @@ -538,6 +538,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers { bytecodeClazz.info val sClass = clazz.owner.newClass(clazzName, clazz.pos, (clazz.flags | SPECIALIZED) & ~CASE) + sClass.setAnnotations(clazz.annotations) // SI-8574 important that the subclass picks up @SerialVersionUID, @strictfp, etc. def cloneInSpecializedClass(member: Symbol, flagFn: Long => Long, newName: Name = null) = member.cloneSymbol(sClass, flagFn(member.flags | SPECIALIZED), newName) diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index bf98c0e3dceb..9fe693ce2ab0 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -1687,7 +1687,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper val sameSourceFile = context.unit.source.file == psym.sourceFile - if (psym.hasDeprecatedInheritanceAnnotation && !sameSourceFile) { + if (!isPastTyper && psym.hasDeprecatedInheritanceAnnotation && !sameSourceFile) { val suffix = psym.deprecatedInheritanceMessage map (": " + _) getOrElse "" val msg = s"inheritance from ${psym.fullLocationString} is deprecated$suffix" unit.deprecationWarning(parent.pos, msg) diff --git a/test/files/neg/t6162-inheritance.check b/test/files/neg/t6162-inheritance.check index 13c78030d955..c9f4ddaec14b 100644 --- a/test/files/neg/t6162-inheritance.check +++ b/test/files/neg/t6162-inheritance.check @@ -7,12 +7,6 @@ object SubT extends T usage.scala:8: warning: inheritance from trait S in package t6126 is deprecated new S { ^ -usage.scala:3: warning: inheritance from class Foo in package t6126 is deprecated: `Foo` will be made final in a future version. -class SubFoo extends Foo - ^ -usage.scala:5: warning: inheritance from trait T in package t6126 is deprecated -object SubT extends T - ^ error: No warnings can be incurred under -Xfatal-warnings. -5 warnings found +three warnings found one error found diff --git a/test/files/run/t8574.scala b/test/files/run/t8574.scala new file mode 100644 index 000000000000..8c23ada48215 --- /dev/null +++ b/test/files/run/t8574.scala @@ -0,0 +1,27 @@ +import annotation._ + +@SerialVersionUID(42) @strictfp class Foo[@specialized(Int) T] extends Serializable { + def foo(t: T) = t +} + +object Test extends App { + def checkUID(cls: Class[_], expected: Long) = { + val actual = java.io.ObjectStreamClass.lookup(cls).getSerialVersionUID + assert(actual == expected, s"$actual != expected for ${cls}") + } + def checkStrictFp(cls: Class[_]) = { + import java.lang.reflect._ + for (m <- cls.getDeclaredMethods) { + val isStrict = Modifier.isStrict(m.getModifiers) + assert(isStrict, cls) + } + } + def check(x: AnyRef) { + checkUID(x.getClass, 42) + checkStrictFp(x.getClass) + } + + check(new Foo[String]) + check(new Foo[Int]) +} + From ee611cd76c29fedd416162e482c7ab3f15b831ca Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sun, 18 May 2014 10:24:43 +0200 Subject: [PATCH 256/826] SI-8601 Don't treat int/long division, or arraylength, as dead-code `{i, l}div` and `{i, l}rem` throw an `ArithmeticException` if the divisor is 0. `arraylength` throws a `NullPointerException` on a null reference. JVM Spec: > The only integer operations that can throw an exception are the > integer divide instructions (idiv and ldiv) and the integer > remainder instructions (irem and lrem), which throw an > ArithmeticException if the divisor is zero. > The Java virtual machine's floating-point operators do not throw > runtime exceptions > If the arrayref is null, the arraylength instruction throws a > NullPointerException. I checked the other primitives in `ICode` to see if anything else should be considered as live code. Pure: // jvm : {i, l, f, d}neg case class Negation(kind: TypeKind) extends Primitive // jvm : if{eq, ne, lt, ge, le, gt}, if{null, nonnull} // if_icmp{eq, ne, lt, ge, le, gt}, if_acmp{eq,ne} case class Test(op: TestOp, kind: TypeKind, zero: Boolean) extends Primitive // jvm : lcmp, {f, d}cmp{l, g} case class Comparison(op: ComparisonOp, kind: TypeKind) extends Primitive Impure: {i, l}{div, rem}, otherwise pure // jvm : {i, l, f, d}{add, sub, mul, div, rem} case class Arithmetic(op: ArithmeticOp, kind: TypeKind) extends Primitive Pure (overflow is silent, NaN.toInt is defined): // jvm : {i, l}{and, or, xor} case class Logical(op: LogicalOp, kind: TypeKind) extends Primitive // jvm : {i, l}{shl, ushl, shr} case class Shift(op: ShiftOp, kind: TypeKind) extends Primitive // jvm : i2{l, f, d}, l2{i, f, d}, f2{i, l, d}, d2{i, l, f}, i2{b, c, s} case class Conversion(src: TypeKind, dst: TypeKind) extends Primitive Impure! May NPE! // jvm : arraylength case class ArrayLength(kind: TypeKind) extends Primitive Pure (we know that StringBuilder.{, append, toString} are pure and `append` is null safe.) // jvm : It should call the appropiate 'append' method on StringBuffer case class StringConcat(el: TypeKind) extends Primitive // jvm: it should create a new StringBuffer case object StartConcat extends Primitive // jvm: convert StringBuffer to a String case object EndConcat extends Primitive --- .../nsc/backend/opt/DeadCodeElimination.scala | 2 ++ test/files/run/t8601.flags | 1 + test/files/run/t8601.scala | 15 +++++++++++++++ test/files/run/t8601b.flags | 1 + test/files/run/t8601b.scala | 9 +++++++++ 5 files changed, 28 insertions(+) create mode 100644 test/files/run/t8601.flags create mode 100644 test/files/run/t8601.scala create mode 100644 test/files/run/t8601b.flags create mode 100644 test/files/run/t8601b.scala diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala index 90c37ba0b37b..3c983e6fdf38 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala @@ -193,6 +193,8 @@ abstract class DeadCodeElimination extends SubComponent { moveToWorkListIf(necessary) case LOAD_MODULE(sym) if isLoadNeeded(sym) => moveToWorkList() // SI-4859 Module initialization might side-effect. + case CALL_PRIMITIVE(Arithmetic(DIV | REM, INT | LONG) | ArrayLength(_)) => + moveToWorkList() // SI-8601 Might divide by zero case _ => () moveToWorkListIf(cond = false) } diff --git a/test/files/run/t8601.flags b/test/files/run/t8601.flags new file mode 100644 index 000000000000..1182725e8633 --- /dev/null +++ b/test/files/run/t8601.flags @@ -0,0 +1 @@ +-optimize \ No newline at end of file diff --git a/test/files/run/t8601.scala b/test/files/run/t8601.scala new file mode 100644 index 000000000000..e1afc23cc415 --- /dev/null +++ b/test/files/run/t8601.scala @@ -0,0 +1,15 @@ +object Test { + def idiv(x: Int): Unit = x / 0 + def ldiv(x: Long): Unit = x / 0 + def irem(x: Int): Unit = x % 0 + def lrem(x: Long): Unit = x % 0 + + def check(x: => Any) = try { x; sys.error("failed to throw divide by zero!") } catch { case _: ArithmeticException => } + + def main(args: Array[String]) { + check(idiv(1)) + check(ldiv(1L)) + check(irem(1)) + check(lrem(1L)) + } +} diff --git a/test/files/run/t8601b.flags b/test/files/run/t8601b.flags new file mode 100644 index 000000000000..1182725e8633 --- /dev/null +++ b/test/files/run/t8601b.flags @@ -0,0 +1 @@ +-optimize \ No newline at end of file diff --git a/test/files/run/t8601b.scala b/test/files/run/t8601b.scala new file mode 100644 index 000000000000..42b562af9670 --- /dev/null +++ b/test/files/run/t8601b.scala @@ -0,0 +1,9 @@ +object Test { + def len(x: Array[String]): Unit = x.length + + def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => } + + def main(args: Array[String]) { + check(len(null)) + } +} From 0b432f9cd22b6e9770852e5b331a15f0534a312c Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sun, 18 May 2014 12:01:17 +0200 Subject: [PATCH 257/826] SI-8601 Avoid over-eager optimization of LOAD_FIELD It can NPE or trigger static class initilization, we can't elimiate it without changing semantics. --- .../tools/nsc/backend/opt/ClosureElimination.scala | 9 ++++----- .../tools/nsc/backend/opt/DeadCodeElimination.scala | 2 +- test/files/run/t8601c.flags | 1 + test/files/run/t8601c.scala | 12 ++++++++++++ 4 files changed, 18 insertions(+), 6 deletions(-) create mode 100644 test/files/run/t8601c.flags create mode 100644 test/files/run/t8601c.scala diff --git a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala index c49f23852f7c..0b943360deb3 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala @@ -56,11 +56,10 @@ abstract class ClosureElimination extends SubComponent { case (BOX(t1), UNBOX(t2)) if (t1 == t2) => Some(Nil) - case (LOAD_FIELD(sym, isStatic), DROP(_)) if !sym.hasAnnotation(definitions.VolatileAttr) => - if (isStatic) - Some(Nil) - else - Some(DROP(REFERENCE(definitions.ObjectClass)) :: Nil) + // Can't eliminate (LOAD_FIELD, DROP) without eliding side effects: + // - static class initialization + // - NPE if the receiver is null + // We could replace the LOAD/DROP with a null check to preserve semantics. case _ => None } diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala index 3c983e6fdf38..64aed19bf0bd 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala @@ -167,7 +167,7 @@ abstract class DeadCodeElimination extends SubComponent { set += idx localStores(key) = set - case RETURN(_) | JUMP(_) | CJUMP(_, _, _, _) | CZJUMP(_, _, _, _) | STORE_FIELD(_, _) | + case RETURN(_) | JUMP(_) | CJUMP(_, _, _, _) | CZJUMP(_, _, _, _) | STORE_FIELD(_, _) | LOAD_FIELD(_, _) | // Why LOAD_FIELD? It can NPE! THROW(_) | LOAD_ARRAY_ITEM(_) | STORE_ARRAY_ITEM(_) | SCOPE_ENTER(_) | SCOPE_EXIT(_) | STORE_THIS(_) | LOAD_EXCEPTION(_) | SWITCH(_, _) | MONITOR_ENTER() | MONITOR_EXIT() | CHECK_CAST(_) => moveToWorkList() diff --git a/test/files/run/t8601c.flags b/test/files/run/t8601c.flags new file mode 100644 index 000000000000..1182725e8633 --- /dev/null +++ b/test/files/run/t8601c.flags @@ -0,0 +1 @@ +-optimize \ No newline at end of file diff --git a/test/files/run/t8601c.scala b/test/files/run/t8601c.scala new file mode 100644 index 000000000000..c487d6825ef5 --- /dev/null +++ b/test/files/run/t8601c.scala @@ -0,0 +1,12 @@ +object Test { + def loadField(x: scala.runtime.IntRef): Unit = x.elem + def storeField(x: scala.runtime.IntRef): Unit = x.elem = 42 + + def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => } + + def main(args: Array[String]) { + check(loadField(null)) // bug: did not NPE under -Ydead-code + check(storeField(null)) + + } +} From 99b4ef8d8472f154d73160f5fe72daf081abb24e Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sun, 18 May 2014 12:11:29 +0200 Subject: [PATCH 258/826] Add a test for array load --- test/files/run/t8601b.scala | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/files/run/t8601b.scala b/test/files/run/t8601b.scala index 42b562af9670..c01caa57d04b 100644 --- a/test/files/run/t8601b.scala +++ b/test/files/run/t8601b.scala @@ -1,9 +1,11 @@ object Test { def len(x: Array[String]): Unit = x.length + def load(x: Array[String]): Unit = x(0) def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => } def main(args: Array[String]) { - check(len(null)) + check(len(null)) // bug: did not NPE + check(load(null)) } } From 70b912a87433c9589af33e4f8b33dca39abb66e5 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sun, 18 May 2014 12:17:02 +0200 Subject: [PATCH 259/826] SI-8601 Don't treat newarray as dead code Otherwise we lose the side effect of a `NegativeArraySizeException`. --- .../scala/tools/nsc/backend/opt/DeadCodeElimination.scala | 2 +- test/files/run/t8601b.scala | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala index 64aed19bf0bd..245894a4af36 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala @@ -169,7 +169,7 @@ abstract class DeadCodeElimination extends SubComponent { case RETURN(_) | JUMP(_) | CJUMP(_, _, _, _) | CZJUMP(_, _, _, _) | STORE_FIELD(_, _) | LOAD_FIELD(_, _) | // Why LOAD_FIELD? It can NPE! THROW(_) | LOAD_ARRAY_ITEM(_) | STORE_ARRAY_ITEM(_) | SCOPE_ENTER(_) | SCOPE_EXIT(_) | STORE_THIS(_) | - LOAD_EXCEPTION(_) | SWITCH(_, _) | MONITOR_ENTER() | MONITOR_EXIT() | CHECK_CAST(_) => + LOAD_EXCEPTION(_) | SWITCH(_, _) | MONITOR_ENTER() | MONITOR_EXIT() | CHECK_CAST(_) | CREATE_ARRAY(_, _) => moveToWorkList() case CALL_METHOD(m1, _) if isSideEffecting(m1) => diff --git a/test/files/run/t8601b.scala b/test/files/run/t8601b.scala index c01caa57d04b..9c37ce33d697 100644 --- a/test/files/run/t8601b.scala +++ b/test/files/run/t8601b.scala @@ -1,11 +1,14 @@ object Test { def len(x: Array[String]): Unit = x.length def load(x: Array[String]): Unit = x(0) + def newarray(i: Int): Unit = new Array[Int](i) def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => } + def checkNegSize(x: => Any) = try { x; sys.error("failed to throw NegativeArraySizeException!") } catch { case _: NegativeArraySizeException => } def main(args: Array[String]) { check(len(null)) // bug: did not NPE check(load(null)) + checkNegSize(newarray(-1)) } } From dcade51d751b389fb5137040f7e1006b4bc633c6 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sun, 18 May 2014 12:21:45 +0200 Subject: [PATCH 260/826] SI-8601 Test that `null.synchronized` NPEs under -optimize As part of my sweep through the side-effecting byte code instructions. --- test/files/run/t8601d.flags | 1 + test/files/run/t8601d.scala | 8 ++++++++ 2 files changed, 9 insertions(+) create mode 100644 test/files/run/t8601d.flags create mode 100644 test/files/run/t8601d.scala diff --git a/test/files/run/t8601d.flags b/test/files/run/t8601d.flags new file mode 100644 index 000000000000..1182725e8633 --- /dev/null +++ b/test/files/run/t8601d.flags @@ -0,0 +1 @@ +-optimize \ No newline at end of file diff --git a/test/files/run/t8601d.scala b/test/files/run/t8601d.scala new file mode 100644 index 000000000000..ac89963d6771 --- /dev/null +++ b/test/files/run/t8601d.scala @@ -0,0 +1,8 @@ +object Test { + def monitor(x: AnyRef): Unit = {x.synchronized(()); ()} + def check(x: => Any) = try { x; sys.error("failed to throw NPE") } catch { case _: NullPointerException => } + + def main(args: Array[String]) { + check(monitor(null)) + } +} From 103c9850c32cd9ebfac548eb88e6d989c11ee57c Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Mon, 19 May 2014 10:53:36 +0200 Subject: [PATCH 261/826] Bump akka-actor version to 2.3.3 (ref SI-8549) Because serialization affected akka, we're upgrading the included akka-actor to 2.3.3, which is built with Scala 2.11.1. --- versions.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/versions.properties b/versions.properties index 0e56f731ed34..2fbd4c466d8f 100644 --- a/versions.properties +++ b/versions.properties @@ -22,7 +22,7 @@ scala-parser-combinators.version.number=1.0.1 scala-continuations-plugin.version.number=1.0.1 scala-continuations-library.version.number=1.0.1 scala-swing.version.number=1.0.1 -akka-actor.version.number=2.3.2 +akka-actor.version.number=2.3.3 actors-migration.version.number=1.1.0 # external modules, used internally (not shipped) From 0e87b12bcf68d9f52d2dee92ff19d04019641110 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Mon, 19 May 2014 12:56:07 +0200 Subject: [PATCH 262/826] Revert "SI-8601 Test that `null.synchronized` NPEs under -optimize" This reverts commit dcade51d751b389fb5137040f7e1006b4bc633c6. --- test/files/run/t8601d.flags | 1 - test/files/run/t8601d.scala | 8 -------- 2 files changed, 9 deletions(-) delete mode 100644 test/files/run/t8601d.flags delete mode 100644 test/files/run/t8601d.scala diff --git a/test/files/run/t8601d.flags b/test/files/run/t8601d.flags deleted file mode 100644 index 1182725e8633..000000000000 --- a/test/files/run/t8601d.flags +++ /dev/null @@ -1 +0,0 @@ --optimize \ No newline at end of file diff --git a/test/files/run/t8601d.scala b/test/files/run/t8601d.scala deleted file mode 100644 index ac89963d6771..000000000000 --- a/test/files/run/t8601d.scala +++ /dev/null @@ -1,8 +0,0 @@ -object Test { - def monitor(x: AnyRef): Unit = {x.synchronized(()); ()} - def check(x: => Any) = try { x; sys.error("failed to throw NPE") } catch { case _: NullPointerException => } - - def main(args: Array[String]) { - check(monitor(null)) - } -} From c3d61574c908d7fee5d16b300449c2958adad9fb Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Mon, 19 May 2014 12:56:09 +0200 Subject: [PATCH 263/826] Revert "SI-8601 Don't treat newarray as dead code" This reverts commit 70b912a87433c9589af33e4f8b33dca39abb66e5. --- .../scala/tools/nsc/backend/opt/DeadCodeElimination.scala | 2 +- test/files/run/t8601b.scala | 3 --- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala index 245894a4af36..64aed19bf0bd 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala @@ -169,7 +169,7 @@ abstract class DeadCodeElimination extends SubComponent { case RETURN(_) | JUMP(_) | CJUMP(_, _, _, _) | CZJUMP(_, _, _, _) | STORE_FIELD(_, _) | LOAD_FIELD(_, _) | // Why LOAD_FIELD? It can NPE! THROW(_) | LOAD_ARRAY_ITEM(_) | STORE_ARRAY_ITEM(_) | SCOPE_ENTER(_) | SCOPE_EXIT(_) | STORE_THIS(_) | - LOAD_EXCEPTION(_) | SWITCH(_, _) | MONITOR_ENTER() | MONITOR_EXIT() | CHECK_CAST(_) | CREATE_ARRAY(_, _) => + LOAD_EXCEPTION(_) | SWITCH(_, _) | MONITOR_ENTER() | MONITOR_EXIT() | CHECK_CAST(_) => moveToWorkList() case CALL_METHOD(m1, _) if isSideEffecting(m1) => diff --git a/test/files/run/t8601b.scala b/test/files/run/t8601b.scala index 9c37ce33d697..c01caa57d04b 100644 --- a/test/files/run/t8601b.scala +++ b/test/files/run/t8601b.scala @@ -1,14 +1,11 @@ object Test { def len(x: Array[String]): Unit = x.length def load(x: Array[String]): Unit = x(0) - def newarray(i: Int): Unit = new Array[Int](i) def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => } - def checkNegSize(x: => Any) = try { x; sys.error("failed to throw NegativeArraySizeException!") } catch { case _: NegativeArraySizeException => } def main(args: Array[String]) { check(len(null)) // bug: did not NPE check(load(null)) - checkNegSize(newarray(-1)) } } From b11a27e3e655105ec6f7640934072ba7966c88a3 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Mon, 19 May 2014 12:56:10 +0200 Subject: [PATCH 264/826] Revert "Add a test for array load" This reverts commit 99b4ef8d8472f154d73160f5fe72daf081abb24e. --- test/files/run/t8601b.scala | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/test/files/run/t8601b.scala b/test/files/run/t8601b.scala index c01caa57d04b..42b562af9670 100644 --- a/test/files/run/t8601b.scala +++ b/test/files/run/t8601b.scala @@ -1,11 +1,9 @@ object Test { def len(x: Array[String]): Unit = x.length - def load(x: Array[String]): Unit = x(0) def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => } def main(args: Array[String]) { - check(len(null)) // bug: did not NPE - check(load(null)) + check(len(null)) } } From f0eb8d93d51b110f11786a5f3664cde9db66efcc Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Mon, 19 May 2014 12:56:11 +0200 Subject: [PATCH 265/826] Revert "SI-8601 Avoid over-eager optimization of LOAD_FIELD" This reverts commit 0b432f9cd22b6e9770852e5b331a15f0534a312c. --- .../tools/nsc/backend/opt/ClosureElimination.scala | 9 +++++---- .../tools/nsc/backend/opt/DeadCodeElimination.scala | 2 +- test/files/run/t8601c.flags | 1 - test/files/run/t8601c.scala | 12 ------------ 4 files changed, 6 insertions(+), 18 deletions(-) delete mode 100644 test/files/run/t8601c.flags delete mode 100644 test/files/run/t8601c.scala diff --git a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala index 0b943360deb3..c49f23852f7c 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala @@ -56,10 +56,11 @@ abstract class ClosureElimination extends SubComponent { case (BOX(t1), UNBOX(t2)) if (t1 == t2) => Some(Nil) - // Can't eliminate (LOAD_FIELD, DROP) without eliding side effects: - // - static class initialization - // - NPE if the receiver is null - // We could replace the LOAD/DROP with a null check to preserve semantics. + case (LOAD_FIELD(sym, isStatic), DROP(_)) if !sym.hasAnnotation(definitions.VolatileAttr) => + if (isStatic) + Some(Nil) + else + Some(DROP(REFERENCE(definitions.ObjectClass)) :: Nil) case _ => None } diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala index 64aed19bf0bd..3c983e6fdf38 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala @@ -167,7 +167,7 @@ abstract class DeadCodeElimination extends SubComponent { set += idx localStores(key) = set - case RETURN(_) | JUMP(_) | CJUMP(_, _, _, _) | CZJUMP(_, _, _, _) | STORE_FIELD(_, _) | LOAD_FIELD(_, _) | // Why LOAD_FIELD? It can NPE! + case RETURN(_) | JUMP(_) | CJUMP(_, _, _, _) | CZJUMP(_, _, _, _) | STORE_FIELD(_, _) | THROW(_) | LOAD_ARRAY_ITEM(_) | STORE_ARRAY_ITEM(_) | SCOPE_ENTER(_) | SCOPE_EXIT(_) | STORE_THIS(_) | LOAD_EXCEPTION(_) | SWITCH(_, _) | MONITOR_ENTER() | MONITOR_EXIT() | CHECK_CAST(_) => moveToWorkList() diff --git a/test/files/run/t8601c.flags b/test/files/run/t8601c.flags deleted file mode 100644 index 1182725e8633..000000000000 --- a/test/files/run/t8601c.flags +++ /dev/null @@ -1 +0,0 @@ --optimize \ No newline at end of file diff --git a/test/files/run/t8601c.scala b/test/files/run/t8601c.scala deleted file mode 100644 index c487d6825ef5..000000000000 --- a/test/files/run/t8601c.scala +++ /dev/null @@ -1,12 +0,0 @@ -object Test { - def loadField(x: scala.runtime.IntRef): Unit = x.elem - def storeField(x: scala.runtime.IntRef): Unit = x.elem = 42 - - def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => } - - def main(args: Array[String]) { - check(loadField(null)) // bug: did not NPE under -Ydead-code - check(storeField(null)) - - } -} From 81309e7e0fb568b3ba12df9631c607232b68960b Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Mon, 19 May 2014 12:56:12 +0200 Subject: [PATCH 266/826] Revert "SI-8601 Don't treat int/long division, or arraylength, as dead-code" This reverts commit ee611cd76c29fedd416162e482c7ab3f15b831ca. --- .../nsc/backend/opt/DeadCodeElimination.scala | 2 -- test/files/run/t8601.flags | 1 - test/files/run/t8601.scala | 15 --------------- test/files/run/t8601b.flags | 1 - test/files/run/t8601b.scala | 9 --------- 5 files changed, 28 deletions(-) delete mode 100644 test/files/run/t8601.flags delete mode 100644 test/files/run/t8601.scala delete mode 100644 test/files/run/t8601b.flags delete mode 100644 test/files/run/t8601b.scala diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala index 3c983e6fdf38..90c37ba0b37b 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala @@ -193,8 +193,6 @@ abstract class DeadCodeElimination extends SubComponent { moveToWorkListIf(necessary) case LOAD_MODULE(sym) if isLoadNeeded(sym) => moveToWorkList() // SI-4859 Module initialization might side-effect. - case CALL_PRIMITIVE(Arithmetic(DIV | REM, INT | LONG) | ArrayLength(_)) => - moveToWorkList() // SI-8601 Might divide by zero case _ => () moveToWorkListIf(cond = false) } diff --git a/test/files/run/t8601.flags b/test/files/run/t8601.flags deleted file mode 100644 index 1182725e8633..000000000000 --- a/test/files/run/t8601.flags +++ /dev/null @@ -1 +0,0 @@ --optimize \ No newline at end of file diff --git a/test/files/run/t8601.scala b/test/files/run/t8601.scala deleted file mode 100644 index e1afc23cc415..000000000000 --- a/test/files/run/t8601.scala +++ /dev/null @@ -1,15 +0,0 @@ -object Test { - def idiv(x: Int): Unit = x / 0 - def ldiv(x: Long): Unit = x / 0 - def irem(x: Int): Unit = x % 0 - def lrem(x: Long): Unit = x % 0 - - def check(x: => Any) = try { x; sys.error("failed to throw divide by zero!") } catch { case _: ArithmeticException => } - - def main(args: Array[String]) { - check(idiv(1)) - check(ldiv(1L)) - check(irem(1)) - check(lrem(1L)) - } -} diff --git a/test/files/run/t8601b.flags b/test/files/run/t8601b.flags deleted file mode 100644 index 1182725e8633..000000000000 --- a/test/files/run/t8601b.flags +++ /dev/null @@ -1 +0,0 @@ --optimize \ No newline at end of file diff --git a/test/files/run/t8601b.scala b/test/files/run/t8601b.scala deleted file mode 100644 index 42b562af9670..000000000000 --- a/test/files/run/t8601b.scala +++ /dev/null @@ -1,9 +0,0 @@ -object Test { - def len(x: Array[String]): Unit = x.length - - def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => } - - def main(args: Array[String]) { - check(len(null)) - } -} From 5b1d43d8ffda4b5881df7ce6634a7adebbb02f21 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sun, 18 May 2014 10:24:43 +0200 Subject: [PATCH 267/826] SI-8601 Don't treat int/long division, or arraylength, as dead-code `{i, l}div` and `{i, l}rem` throw an `ArithmeticException` if the divisor is 0. `arraylength` throws a `NullPointerException` on a null reference. JVM Spec: > The only integer operations that can throw an exception are the > integer divide instructions (idiv and ldiv) and the integer > remainder instructions (irem and lrem), which throw an > ArithmeticException if the divisor is zero. > The Java virtual machine's floating-point operators do not throw > runtime exceptions > If the arrayref is null, the arraylength instruction throws a > NullPointerException. I checked the other primitives in `ICode` to see if anything else should be considered as live code. Pure: // jvm : {i, l, f, d}neg case class Negation(kind: TypeKind) extends Primitive // jvm : if{eq, ne, lt, ge, le, gt}, if{null, nonnull} // if_icmp{eq, ne, lt, ge, le, gt}, if_acmp{eq,ne} case class Test(op: TestOp, kind: TypeKind, zero: Boolean) extends Primitive // jvm : lcmp, {f, d}cmp{l, g} case class Comparison(op: ComparisonOp, kind: TypeKind) extends Primitive Impure: {i, l}{div, rem}, otherwise pure // jvm : {i, l, f, d}{add, sub, mul, div, rem} case class Arithmetic(op: ArithmeticOp, kind: TypeKind) extends Primitive Pure (overflow is silent, NaN.toInt is defined): // jvm : {i, l}{and, or, xor} case class Logical(op: LogicalOp, kind: TypeKind) extends Primitive // jvm : {i, l}{shl, ushl, shr} case class Shift(op: ShiftOp, kind: TypeKind) extends Primitive // jvm : i2{l, f, d}, l2{i, f, d}, f2{i, l, d}, d2{i, l, f}, i2{b, c, s} case class Conversion(src: TypeKind, dst: TypeKind) extends Primitive Impure! May NPE! // jvm : arraylength case class ArrayLength(kind: TypeKind) extends Primitive Pure (we know that StringBuilder.{, append, toString} are pure and `append` is null safe.) // jvm : It should call the appropiate 'append' method on StringBuffer case class StringConcat(el: TypeKind) extends Primitive // jvm: it should create a new StringBuffer case object StartConcat extends Primitive // jvm: convert StringBuffer to a String case object EndConcat extends Primitive --- .../nsc/backend/opt/DeadCodeElimination.scala | 2 ++ test/files/run/t8601.flags | 1 + test/files/run/t8601.scala | 15 +++++++++++++++ test/files/run/t8601b.flags | 1 + test/files/run/t8601b.scala | 9 +++++++++ 5 files changed, 28 insertions(+) create mode 100644 test/files/run/t8601.flags create mode 100644 test/files/run/t8601.scala create mode 100644 test/files/run/t8601b.flags create mode 100644 test/files/run/t8601b.scala diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala index 90c37ba0b37b..3c983e6fdf38 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala @@ -193,6 +193,8 @@ abstract class DeadCodeElimination extends SubComponent { moveToWorkListIf(necessary) case LOAD_MODULE(sym) if isLoadNeeded(sym) => moveToWorkList() // SI-4859 Module initialization might side-effect. + case CALL_PRIMITIVE(Arithmetic(DIV | REM, INT | LONG) | ArrayLength(_)) => + moveToWorkList() // SI-8601 Might divide by zero case _ => () moveToWorkListIf(cond = false) } diff --git a/test/files/run/t8601.flags b/test/files/run/t8601.flags new file mode 100644 index 000000000000..1182725e8633 --- /dev/null +++ b/test/files/run/t8601.flags @@ -0,0 +1 @@ +-optimize \ No newline at end of file diff --git a/test/files/run/t8601.scala b/test/files/run/t8601.scala new file mode 100644 index 000000000000..e1afc23cc415 --- /dev/null +++ b/test/files/run/t8601.scala @@ -0,0 +1,15 @@ +object Test { + def idiv(x: Int): Unit = x / 0 + def ldiv(x: Long): Unit = x / 0 + def irem(x: Int): Unit = x % 0 + def lrem(x: Long): Unit = x % 0 + + def check(x: => Any) = try { x; sys.error("failed to throw divide by zero!") } catch { case _: ArithmeticException => } + + def main(args: Array[String]) { + check(idiv(1)) + check(ldiv(1L)) + check(irem(1)) + check(lrem(1L)) + } +} diff --git a/test/files/run/t8601b.flags b/test/files/run/t8601b.flags new file mode 100644 index 000000000000..1182725e8633 --- /dev/null +++ b/test/files/run/t8601b.flags @@ -0,0 +1 @@ +-optimize \ No newline at end of file diff --git a/test/files/run/t8601b.scala b/test/files/run/t8601b.scala new file mode 100644 index 000000000000..42b562af9670 --- /dev/null +++ b/test/files/run/t8601b.scala @@ -0,0 +1,9 @@ +object Test { + def len(x: Array[String]): Unit = x.length + + def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => } + + def main(args: Array[String]) { + check(len(null)) + } +} From ccc5eef051c8588c1fe4029e832d5b6387976aa6 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sun, 18 May 2014 12:01:17 +0200 Subject: [PATCH 268/826] SI-8601 Avoid over-eager optimization of LOAD_FIELD It can NPE or trigger static class initilization, we can't elimiate it without changing semantics. To make sure we don't thwart closure elimination, I've allowed DCE to eliminate a non-static LOAD_FIELD of a member of a closure class. It would be more general to track nullity of the reciever (e.g, `this` or `new Foo` cannot be null), but that would require more infrastructure in this phase. I've added a test for closure inlining based on a a suggestion by @dragos. This actually passes if we remove the (LOAD_FIELD, DROP) peephole optimization for `closelim` altogether. But I chose to adapt that optimization (only allow it for non-static, closure fields), rather then remove it alogether, in the interests of treading lightly. --- .../nsc/backend/opt/ClosureElimination.scala | 7 ++--- .../nsc/backend/opt/DeadCodeElimination.scala | 5 ++++ test/files/run/t8601-closure-elim.flags | 1 + test/files/run/t8601-closure-elim.scala | 26 +++++++++++++++++++ test/files/run/t8601c.flags | 1 + test/files/run/t8601c.scala | 12 +++++++++ 6 files changed, 47 insertions(+), 5 deletions(-) create mode 100644 test/files/run/t8601-closure-elim.flags create mode 100644 test/files/run/t8601-closure-elim.scala create mode 100644 test/files/run/t8601c.flags create mode 100644 test/files/run/t8601c.scala diff --git a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala index c49f23852f7c..a866173a8849 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala @@ -56,11 +56,8 @@ abstract class ClosureElimination extends SubComponent { case (BOX(t1), UNBOX(t2)) if (t1 == t2) => Some(Nil) - case (LOAD_FIELD(sym, isStatic), DROP(_)) if !sym.hasAnnotation(definitions.VolatileAttr) => - if (isStatic) - Some(Nil) - else - Some(DROP(REFERENCE(definitions.ObjectClass)) :: Nil) + case (LOAD_FIELD(sym, /* isStatic */false), DROP(_)) if !sym.hasAnnotation(definitions.VolatileAttr) && inliner.isClosureClass(sym.owner) => + Some(DROP(REFERENCE(definitions.ObjectClass)) :: Nil) case _ => None } diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala index 3c983e6fdf38..18bf63e237a6 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala @@ -172,6 +172,11 @@ abstract class DeadCodeElimination extends SubComponent { LOAD_EXCEPTION(_) | SWITCH(_, _) | MONITOR_ENTER() | MONITOR_EXIT() | CHECK_CAST(_) => moveToWorkList() + case LOAD_FIELD(sym, isStatic) if isStatic || !inliner.isClosureClass(sym.owner) => + // static load may trigger static initization. + // non-static load can throw NPE (but we know closure fields can't be accessed via a + // null reference. + moveToWorkList() case CALL_METHOD(m1, _) if isSideEffecting(m1) => moveToWorkList() diff --git a/test/files/run/t8601-closure-elim.flags b/test/files/run/t8601-closure-elim.flags new file mode 100644 index 000000000000..49d036a8879c --- /dev/null +++ b/test/files/run/t8601-closure-elim.flags @@ -0,0 +1 @@ +-optimize diff --git a/test/files/run/t8601-closure-elim.scala b/test/files/run/t8601-closure-elim.scala new file mode 100644 index 000000000000..2c5b03af772a --- /dev/null +++ b/test/files/run/t8601-closure-elim.scala @@ -0,0 +1,26 @@ +import scala.tools.partest.BytecodeTest +import scala.tools.asm +import scala.tools.asm.util._ +import scala.collection.JavaConverters._ + +object Test extends BytecodeTest { + val nullChecks = Set(asm.Opcodes.NEW) + + def show: Unit = { + def test(methodName: String) { + val classNode = loadClassNode("Foo") + val methodNode = getMethod(classNode, "b") + val ops = methodNode.instructions.iterator.asScala.map(_.getOpcode).toList + assert(!ops.contains(asm.Opcodes.NEW), ops)// should be allocation free if the closure is eliminiated + } + test("b") + } +} + +class Foo { + @inline final def a(x: Int => Int) = x(1) + final def b { + val delta = 0 + a(x => delta + 1) + } +} diff --git a/test/files/run/t8601c.flags b/test/files/run/t8601c.flags new file mode 100644 index 000000000000..1182725e8633 --- /dev/null +++ b/test/files/run/t8601c.flags @@ -0,0 +1 @@ +-optimize \ No newline at end of file diff --git a/test/files/run/t8601c.scala b/test/files/run/t8601c.scala new file mode 100644 index 000000000000..c487d6825ef5 --- /dev/null +++ b/test/files/run/t8601c.scala @@ -0,0 +1,12 @@ +object Test { + def loadField(x: scala.runtime.IntRef): Unit = x.elem + def storeField(x: scala.runtime.IntRef): Unit = x.elem = 42 + + def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => } + + def main(args: Array[String]) { + check(loadField(null)) // bug: did not NPE under -Ydead-code + check(storeField(null)) + + } +} From a9a3d7c6493f69a099c4ec3179b9bc144d324413 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sun, 18 May 2014 12:11:29 +0200 Subject: [PATCH 269/826] Add a test for array load --- test/files/run/t8601b.scala | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/files/run/t8601b.scala b/test/files/run/t8601b.scala index 42b562af9670..c01caa57d04b 100644 --- a/test/files/run/t8601b.scala +++ b/test/files/run/t8601b.scala @@ -1,9 +1,11 @@ object Test { def len(x: Array[String]): Unit = x.length + def load(x: Array[String]): Unit = x(0) def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => } def main(args: Array[String]) { - check(len(null)) + check(len(null)) // bug: did not NPE + check(load(null)) } } From ae0fe9e507b12dc07f9cac2d6774a7bb270e9998 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sun, 18 May 2014 12:17:02 +0200 Subject: [PATCH 270/826] SI-8601 Don't treat newarray as dead code Otherwise we lose the side effect of a `NegativeArraySizeException`. --- .../scala/tools/nsc/backend/opt/DeadCodeElimination.scala | 2 +- test/files/run/t8601b.scala | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala index 18bf63e237a6..4b419b210c94 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/DeadCodeElimination.scala @@ -169,7 +169,7 @@ abstract class DeadCodeElimination extends SubComponent { case RETURN(_) | JUMP(_) | CJUMP(_, _, _, _) | CZJUMP(_, _, _, _) | STORE_FIELD(_, _) | THROW(_) | LOAD_ARRAY_ITEM(_) | STORE_ARRAY_ITEM(_) | SCOPE_ENTER(_) | SCOPE_EXIT(_) | STORE_THIS(_) | - LOAD_EXCEPTION(_) | SWITCH(_, _) | MONITOR_ENTER() | MONITOR_EXIT() | CHECK_CAST(_) => + LOAD_EXCEPTION(_) | SWITCH(_, _) | MONITOR_ENTER() | MONITOR_EXIT() | CHECK_CAST(_) | CREATE_ARRAY(_, _) => moveToWorkList() case LOAD_FIELD(sym, isStatic) if isStatic || !inliner.isClosureClass(sym.owner) => diff --git a/test/files/run/t8601b.scala b/test/files/run/t8601b.scala index c01caa57d04b..9c37ce33d697 100644 --- a/test/files/run/t8601b.scala +++ b/test/files/run/t8601b.scala @@ -1,11 +1,14 @@ object Test { def len(x: Array[String]): Unit = x.length def load(x: Array[String]): Unit = x(0) + def newarray(i: Int): Unit = new Array[Int](i) def check(x: => Any) = try { x; sys.error("failed to throw NPE!") } catch { case _: NullPointerException => } + def checkNegSize(x: => Any) = try { x; sys.error("failed to throw NegativeArraySizeException!") } catch { case _: NegativeArraySizeException => } def main(args: Array[String]) { check(len(null)) // bug: did not NPE check(load(null)) + checkNegSize(newarray(-1)) } } From 51c60a93009c4470343888e424f58229ecf52ec6 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sun, 18 May 2014 12:21:45 +0200 Subject: [PATCH 271/826] SI-8601 Test that `null.synchronized` NPEs under -optimize As part of my sweep through the side-effecting byte code instructions. --- test/files/run/t8601d.flags | 1 + test/files/run/t8601d.scala | 8 ++++++++ 2 files changed, 9 insertions(+) create mode 100644 test/files/run/t8601d.flags create mode 100644 test/files/run/t8601d.scala diff --git a/test/files/run/t8601d.flags b/test/files/run/t8601d.flags new file mode 100644 index 000000000000..1182725e8633 --- /dev/null +++ b/test/files/run/t8601d.flags @@ -0,0 +1 @@ +-optimize \ No newline at end of file diff --git a/test/files/run/t8601d.scala b/test/files/run/t8601d.scala new file mode 100644 index 000000000000..ac89963d6771 --- /dev/null +++ b/test/files/run/t8601d.scala @@ -0,0 +1,8 @@ +object Test { + def monitor(x: AnyRef): Unit = {x.synchronized(()); ()} + def check(x: => Any) = try { x; sys.error("failed to throw NPE") } catch { case _: NullPointerException => } + + def main(args: Array[String]) { + check(monitor(null)) + } +} From b6cea5f0b6acd976969af72c10d521cbc154b9c9 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 20 May 2014 11:14:30 +0200 Subject: [PATCH 272/826] Bump versions for Scala 2.11.1 --- versions.properties | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/versions.properties b/versions.properties index 2fbd4c466d8f..1212734d22c3 100644 --- a/versions.properties +++ b/versions.properties @@ -1,10 +1,10 @@ -#Wed, 16 Apr 2014 11:13:08 +0200 +#Tue, 20 May 2014 10:01:37 +0200 # NOTE: this file determines the content of the scala-distribution # via scala-dist-pom.xml and scala-library-all-pom.xml # when adding new properties that influence a release, # also add them to the update.versions mechanism in build.xml, # which is used by scala-release-2.11.x in scala/jenkins-scripts -starr.version=2.11.0 +starr.version=2.11.1 starr.use.released=1 # These are the versions of the modules that go with this release. @@ -14,13 +14,13 @@ starr.use.released=1 scala.binary.version=2.11 # e.g. 2.11.0-RC1, 2.11.0, 2.11.1-RC1, 2.11.1 # this defines the dependency on scala-continuations-plugin in scala-dist's pom -scala.full.version=2.11.0 +scala.full.version=2.11.1 # external modules shipped with distribution, as specified by scala-library-all's pom -scala-xml.version.number=1.0.1 +scala-xml.version.number=1.0.2 scala-parser-combinators.version.number=1.0.1 -scala-continuations-plugin.version.number=1.0.1 -scala-continuations-library.version.number=1.0.1 +scala-continuations-plugin.version.number=1.0.2 +scala-continuations-library.version.number=1.0.2 scala-swing.version.number=1.0.1 akka-actor.version.number=2.3.3 actors-migration.version.number=1.1.0 From 7892bbf38fb77e7d2f1361515f14280b3a513c96 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Tue, 20 May 2014 12:31:00 +0200 Subject: [PATCH 273/826] SI-8601 Test that static LOAD_FIELD is not eliminated This test fails under 2.11.0, and works now that DCE treats static loads as useful instructions. --- test/files/run/t8601e.flags | 1 + test/files/run/t8601e/StaticInit.class | Bin 0 -> 417 bytes test/files/run/t8601e/StaticInit.java | 8 ++++++++ test/files/run/t8601e/Test.scala | 12 ++++++++++++ 4 files changed, 21 insertions(+) create mode 100644 test/files/run/t8601e.flags create mode 100644 test/files/run/t8601e/StaticInit.class create mode 100644 test/files/run/t8601e/StaticInit.java create mode 100644 test/files/run/t8601e/Test.scala diff --git a/test/files/run/t8601e.flags b/test/files/run/t8601e.flags new file mode 100644 index 000000000000..49d036a8879c --- /dev/null +++ b/test/files/run/t8601e.flags @@ -0,0 +1 @@ +-optimize diff --git a/test/files/run/t8601e/StaticInit.class b/test/files/run/t8601e/StaticInit.class new file mode 100644 index 0000000000000000000000000000000000000000..99a0e2a643d76e1528a256cbcaad359d2bfbc85d GIT binary patch literal 417 zcmY*VO-sW-5Pj36O`4`nY_)2&f;a8Kg6E$KgFLRf&~S= z`=i83C>HlHJM;FvH#7VF^Zp57A6pho)J!Z}SV7&uss$ajA`GkE6(P@NJY}6S(&&Ej$SBf_@$h zMX3Hko|?#bKrrNecQjT{*&a98=6)uB2C*Sqa+c$qC*fG;s>wGGg?wuUddY|tj)e^5 zW#Rl$4_TU?dNub3?HQ#H=+`skzueX<3aK`SR9k_@QDdzRm)pBpMJ`(|Wu)pa(sfEe literal 0 HcmV?d00001 diff --git a/test/files/run/t8601e/StaticInit.java b/test/files/run/t8601e/StaticInit.java new file mode 100644 index 000000000000..7543ed98b806 --- /dev/null +++ b/test/files/run/t8601e/StaticInit.java @@ -0,0 +1,8 @@ +public class StaticInit { + static { + if ("".isEmpty()) { + throw new RuntimeException(); + } + } + public static int fld = 42; +} diff --git a/test/files/run/t8601e/Test.scala b/test/files/run/t8601e/Test.scala new file mode 100644 index 000000000000..838114f6a7eb --- /dev/null +++ b/test/files/run/t8601e/Test.scala @@ -0,0 +1,12 @@ +class C { + def foo: Unit = {StaticInit.fld} +} + +object Test extends App { + try { + new C().foo + sys.error("StaticInit. was not run!") + } catch { + case t: ExceptionInInitializerError => + } +} From 2cd8f4535a82ea0df919c06fd1ea73ee02f9bad9 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Wed, 14 May 2014 09:03:05 +0200 Subject: [PATCH 274/826] Upgrade ASM to 5.0.2 This commit is a squashed version of all commits in PR #3747. For future upgrades, consult the README and check the commits in https://github.com/scala/scala/pull/3747/commits There's one bug in ASM 5.0.2 that breaks scalac: http://forge.ow2.org/tracker/?func=detail&aid=317200&group_id=23&atid=100023 This bug is fixed in ASM trunk, the patch has been merged into this commit. A future upgrade of ASM should contain the fix. --- src/asm/README | 30 ++ .../scala/tools/asm/AnnotationVisitor.java | 8 +- src/asm/scala/tools/asm/AnnotationWriter.java | 55 ++- src/asm/scala/tools/asm/ByteVector.java | 99 ++-- src/asm/scala/tools/asm/ClassReader.java | 366 ++++++++++++-- src/asm/scala/tools/asm/ClassVisitor.java | 46 +- src/asm/scala/tools/asm/ClassWriter.java | 124 ++++- src/asm/scala/tools/asm/Context.java | 35 ++ src/asm/scala/tools/asm/CustomAttr.java | 2 +- src/asm/scala/tools/asm/FieldVisitor.java | 41 +- src/asm/scala/tools/asm/FieldWriter.java | 58 ++- src/asm/scala/tools/asm/Frame.java | 23 +- src/asm/scala/tools/asm/Handle.java | 13 +- src/asm/scala/tools/asm/Item.java | 3 +- src/asm/scala/tools/asm/MethodVisitor.java | 254 +++++++++- src/asm/scala/tools/asm/MethodWriter.java | 338 ++++++++++--- src/asm/scala/tools/asm/Opcodes.java | 7 +- src/asm/scala/tools/asm/Type.java | 11 +- src/asm/scala/tools/asm/TypePath.java | 193 ++++++++ src/asm/scala/tools/asm/TypeReference.java | 452 ++++++++++++++++++ .../tools/asm/signature/SignatureVisitor.java | 7 +- .../tools/asm/signature/SignatureWriter.java | 2 +- .../tools/asm/tree/AbstractInsnNode.java | 78 +++ .../scala/tools/asm/tree/AnnotationNode.java | 14 +- src/asm/scala/tools/asm/tree/ClassNode.java | 80 +++- .../scala/tools/asm/tree/FieldInsnNode.java | 8 +- src/asm/scala/tools/asm/tree/FieldNode.java | 76 ++- .../scala/tools/asm/tree/IincInsnNode.java | 3 +- src/asm/scala/tools/asm/tree/InsnList.java | 20 +- src/asm/scala/tools/asm/tree/InsnNode.java | 3 +- src/asm/scala/tools/asm/tree/IntInsnNode.java | 3 +- .../tools/asm/tree/InvokeDynamicInsnNode.java | 4 +- .../scala/tools/asm/tree/JumpInsnNode.java | 4 +- src/asm/scala/tools/asm/tree/LdcInsnNode.java | 3 +- .../asm/tree/LocalVariableAnnotationNode.java | 157 ++++++ .../tools/asm/tree/LookupSwitchInsnNode.java | 3 +- .../scala/tools/asm/tree/MethodInsnNode.java | 35 +- src/asm/scala/tools/asm/tree/MethodNode.java | 260 +++++++++- .../asm/tree/MultiANewArrayInsnNode.java | 3 +- .../scala/tools/asm/tree/ParameterNode.java | 76 +++ .../tools/asm/tree/TableSwitchInsnNode.java | 3 +- .../tools/asm/tree/TryCatchBlockNode.java | 59 +++ .../tools/asm/tree/TypeAnnotationNode.java | 100 ++++ .../scala/tools/asm/tree/TypeInsnNode.java | 3 +- src/asm/scala/tools/asm/tree/VarInsnNode.java | 3 +- .../asm/tree/analysis/AnalyzerException.java | 1 + .../asm/tree/analysis/BasicInterpreter.java | 2 +- .../asm/tree/analysis/BasicVerifier.java | 2 +- .../scala/tools/asm/tree/analysis/Frame.java | 9 + .../asm/tree/analysis/SimpleVerifier.java | 2 +- .../asm/tree/analysis/SourceInterpreter.java | 2 +- src/asm/scala/tools/asm/util/ASMifier.java | 141 +++++- .../asm/util/CheckAnnotationAdapter.java | 4 +- .../tools/asm/util/CheckClassAdapter.java | 119 ++++- .../tools/asm/util/CheckFieldAdapter.java | 26 +- .../tools/asm/util/CheckMethodAdapter.java | 159 +++++- .../tools/asm/util/CheckSignatureAdapter.java | 4 +- src/asm/scala/tools/asm/util/Printer.java | 95 +++- src/asm/scala/tools/asm/util/Textifier.java | 279 ++++++++++- .../asm/util/TraceAnnotationVisitor.java | 2 +- .../tools/asm/util/TraceClassVisitor.java | 13 +- .../tools/asm/util/TraceFieldVisitor.java | 13 +- .../tools/asm/util/TraceMethodVisitor.java | 77 ++- .../tools/asm/util/TraceSignatureVisitor.java | 4 +- .../tools/nsc/backend/jvm/BCodeHelpers.scala | 7 +- .../nsc/backend/jvm/BCodeIdiomatic.scala | 8 +- .../nsc/backend/jvm/BCodeSkelBuilder.scala | 6 +- .../scala/tools/nsc/backend/jvm/GenASM.scala | 17 +- .../partest/javaagent/ProfilerVisitor.java | 2 +- test/files/run/classfile-format-51.scala | 14 +- test/files/run/large_class.check | 3 + test/files/run/large_class.scala | 27 ++ 72 files changed, 3883 insertions(+), 320 deletions(-) create mode 100644 src/asm/README create mode 100644 src/asm/scala/tools/asm/TypePath.java create mode 100644 src/asm/scala/tools/asm/TypeReference.java create mode 100644 src/asm/scala/tools/asm/tree/LocalVariableAnnotationNode.java create mode 100644 src/asm/scala/tools/asm/tree/ParameterNode.java create mode 100644 src/asm/scala/tools/asm/tree/TypeAnnotationNode.java create mode 100644 test/files/run/large_class.check create mode 100644 test/files/run/large_class.scala diff --git a/src/asm/README b/src/asm/README new file mode 100644 index 000000000000..3ceac8809821 --- /dev/null +++ b/src/asm/README @@ -0,0 +1,30 @@ +Version 5.0.2, SVN r1741, tags/ASM_5_0_2 + +Git SVN repo: https://github.com/lrytz/asm + - git svn howto: https://github.com/lrytz/asm/issues/1 + +Upgrading ASM +------------- + +Start by deleting all source files in src/asm/ and copy the ones from the latest ASM release. + +Excluded Files (don't copy): + - package.html files + - org/objectweb/asm/commons + - org/objectweb/asm/optimizer + - org/objectweb/asm/xml + +Re-packaging and cosmetic changes: + - convert line endings (there are some CRLF) + find src/asm/scala/tools/asm -name '*.java' | xargs dos2unix + - change package clauses + find src/asm/scala/tools/asm -name '*.java' | xargs sed -i '' -e 's/package org\.objectweb\.asm/package scala.tools.asm/' + - update imports + find src/asm/scala/tools/asm -name '*.java' | xargs sed -i '' -e 's/import org\.objectweb\.asm/import scala.tools.asm/' + - update @links, @associates + find src/asm/scala/tools/asm -name '*.java' | xargs sed -i '' -e 's/@link org\.objectweb\.asm/@link scala.tools.asm/' + find src/asm/scala/tools/asm -name '*.java' | xargs sed -i '' -e 's/@associates org\.objectweb\.asm/@associates scala.tools.asm/' + - remove trailing whitespace + find src/asm/scala/tools/asm -name '*.java' | xargs sed -i '' -e 's/[ ]*$//' + +Actual changes: check the git log for [asm-cherry-pick] after the previous upgrade. diff --git a/src/asm/scala/tools/asm/AnnotationVisitor.java b/src/asm/scala/tools/asm/AnnotationVisitor.java index c806ca71e8fa..abcaf1d6d151 100644 --- a/src/asm/scala/tools/asm/AnnotationVisitor.java +++ b/src/asm/scala/tools/asm/AnnotationVisitor.java @@ -41,7 +41,7 @@ public abstract class AnnotationVisitor { /** * The ASM API version implemented by this visitor. The value of this field - * must be one of {@link Opcodes#ASM4}. + * must be one of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. */ protected final int api; @@ -56,7 +56,7 @@ public abstract class AnnotationVisitor { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. */ public AnnotationVisitor(final int api) { this(api, null); @@ -67,13 +67,13 @@ public AnnotationVisitor(final int api) { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. * @param av * the annotation visitor to which this visitor must delegate * method calls. May be null. */ public AnnotationVisitor(final int api, final AnnotationVisitor av) { - if (api != Opcodes.ASM4) { + if (api != Opcodes.ASM4 && api != Opcodes.ASM5) { throw new IllegalArgumentException(); } this.api = api; diff --git a/src/asm/scala/tools/asm/AnnotationWriter.java b/src/asm/scala/tools/asm/AnnotationWriter.java index 8eb5b2ef4831..6de74ce04122 100644 --- a/src/asm/scala/tools/asm/AnnotationWriter.java +++ b/src/asm/scala/tools/asm/AnnotationWriter.java @@ -104,7 +104,7 @@ final class AnnotationWriter extends AnnotationVisitor { */ AnnotationWriter(final ClassWriter cw, final boolean named, final ByteVector bv, final ByteVector parent, final int offset) { - super(Opcodes.ASM4); + super(Opcodes.ASM5); this.cw = cw; this.named = named; this.bv = bv; @@ -315,4 +315,57 @@ static void put(final AnnotationWriter[] panns, final int off, } } } + + /** + * Puts the given type reference and type path into the given bytevector. + * LOCAL_VARIABLE and RESOURCE_VARIABLE target types are not supported. + * + * @param typeRef + * a reference to the annotated type. See {@link TypeReference}. + * @param typePath + * the path to the annotated type argument, wildcard bound, array + * element type, or static inner type within 'typeRef'. May be + * null if the annotation targets 'typeRef' as a whole. + * @param out + * where the type reference and type path must be put. + */ + static void putTarget(int typeRef, TypePath typePath, ByteVector out) { + switch (typeRef >>> 24) { + case 0x00: // CLASS_TYPE_PARAMETER + case 0x01: // METHOD_TYPE_PARAMETER + case 0x16: // METHOD_FORMAL_PARAMETER + out.putShort(typeRef >>> 16); + break; + case 0x13: // FIELD + case 0x14: // METHOD_RETURN + case 0x15: // METHOD_RECEIVER + out.putByte(typeRef >>> 24); + break; + case 0x47: // CAST + case 0x48: // CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT + case 0x49: // METHOD_INVOCATION_TYPE_ARGUMENT + case 0x4A: // CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT + case 0x4B: // METHOD_REFERENCE_TYPE_ARGUMENT + out.putInt(typeRef); + break; + // case 0x10: // CLASS_EXTENDS + // case 0x11: // CLASS_TYPE_PARAMETER_BOUND + // case 0x12: // METHOD_TYPE_PARAMETER_BOUND + // case 0x17: // THROWS + // case 0x42: // EXCEPTION_PARAMETER + // case 0x43: // INSTANCEOF + // case 0x44: // NEW + // case 0x45: // CONSTRUCTOR_REFERENCE + // case 0x46: // METHOD_REFERENCE + default: + out.put12(typeRef >>> 24, (typeRef & 0xFFFF00) >> 8); + break; + } + if (typePath == null) { + out.putByte(0); + } else { + int length = typePath.b[typePath.offset] * 2 + 1; + out.putByteArray(typePath.b, typePath.offset, length); + } + } } diff --git a/src/asm/scala/tools/asm/ByteVector.java b/src/asm/scala/tools/asm/ByteVector.java index 2bc63eb38442..3bca7af12a44 100644 --- a/src/asm/scala/tools/asm/ByteVector.java +++ b/src/asm/scala/tools/asm/ByteVector.java @@ -204,11 +204,14 @@ public ByteVector putLong(final long l) { * automatically enlarged if necessary. * * @param s - * a String. + * a String whose UTF8 encoded length must be less than 65536. * @return this byte vector. */ public ByteVector putUTF8(final String s) { int charLength = s.length(); + if (charLength > 65535) { + throw new IllegalArgumentException(); + } int len = length; if (len + 2 + charLength > data.length) { enlarge(2 + charLength); @@ -227,38 +230,68 @@ public ByteVector putUTF8(final String s) { if (c >= '\001' && c <= '\177') { data[len++] = (byte) c; } else { - int byteLength = i; - for (int j = i; j < charLength; ++j) { - c = s.charAt(j); - if (c >= '\001' && c <= '\177') { - byteLength++; - } else if (c > '\u07FF') { - byteLength += 3; - } else { - byteLength += 2; - } - } - data[length] = (byte) (byteLength >>> 8); - data[length + 1] = (byte) byteLength; - if (length + 2 + byteLength > data.length) { - length = len; - enlarge(2 + byteLength); - data = this.data; - } - for (int j = i; j < charLength; ++j) { - c = s.charAt(j); - if (c >= '\001' && c <= '\177') { - data[len++] = (byte) c; - } else if (c > '\u07FF') { - data[len++] = (byte) (0xE0 | c >> 12 & 0xF); - data[len++] = (byte) (0x80 | c >> 6 & 0x3F); - data[len++] = (byte) (0x80 | c & 0x3F); - } else { - data[len++] = (byte) (0xC0 | c >> 6 & 0x1F); - data[len++] = (byte) (0x80 | c & 0x3F); - } - } - break; + length = len; + return encodeUTF8(s, i, 65535); + } + } + length = len; + return this; + } + + /** + * Puts an UTF8 string into this byte vector. The byte vector is + * automatically enlarged if necessary. The string length is encoded in two + * bytes before the encoded characters, if there is space for that (i.e. if + * this.length - i - 2 >= 0). + * + * @param s + * the String to encode. + * @param i + * the index of the first character to encode. The previous + * characters are supposed to have already been encoded, using + * only one byte per character. + * @param maxByteLength + * the maximum byte length of the encoded string, including the + * already encoded characters. + * @return this byte vector. + */ + ByteVector encodeUTF8(final String s, int i, int maxByteLength) { + int charLength = s.length(); + int byteLength = i; + char c; + for (int j = i; j < charLength; ++j) { + c = s.charAt(j); + if (c >= '\001' && c <= '\177') { + byteLength++; + } else if (c > '\u07FF') { + byteLength += 3; + } else { + byteLength += 2; + } + } + if (byteLength > maxByteLength) { + throw new IllegalArgumentException(); + } + int start = length - i - 2; + if (start >= 0) { + data[start] = (byte) (byteLength >>> 8); + data[start + 1] = (byte) byteLength; + } + if (length + byteLength - i > data.length) { + enlarge(byteLength - i); + } + int len = length; + for (int j = i; j < charLength; ++j) { + c = s.charAt(j); + if (c >= '\001' && c <= '\177') { + data[len++] = (byte) c; + } else if (c > '\u07FF') { + data[len++] = (byte) (0xE0 | c >> 12 & 0xF); + data[len++] = (byte) (0x80 | c >> 6 & 0x3F); + data[len++] = (byte) (0x80 | c & 0x3F); + } else { + data[len++] = (byte) (0xC0 | c >> 6 & 0x1F); + data[len++] = (byte) (0x80 | c & 0x3F); } } length = len; diff --git a/src/asm/scala/tools/asm/ClassReader.java b/src/asm/scala/tools/asm/ClassReader.java index cc655c1b6274..8b0e12cb049b 100644 --- a/src/asm/scala/tools/asm/ClassReader.java +++ b/src/asm/scala/tools/asm/ClassReader.java @@ -166,7 +166,7 @@ public ClassReader(final byte[] b) { public ClassReader(final byte[] b, final int off, final int len) { this.b = b; // checks the class version - if (readShort(off + 6) > Opcodes.V1_7) { + if (readShort(off + 6) > Opcodes.V1_8) { throw new IllegalArgumentException(); } // parses the constant pool @@ -557,6 +557,8 @@ public void accept(final ClassVisitor classVisitor, String enclosingDesc = null; int anns = 0; int ianns = 0; + int tanns = 0; + int itanns = 0; int innerClasses = 0; Attribute attributes = null; @@ -581,6 +583,9 @@ public void accept(final ClassVisitor classVisitor, } else if (ANNOTATIONS && "RuntimeVisibleAnnotations".equals(attrName)) { anns = u + 8; + } else if (ANNOTATIONS + && "RuntimeVisibleTypeAnnotations".equals(attrName)) { + tanns = u + 8; } else if ("Deprecated".equals(attrName)) { access |= Opcodes.ACC_DEPRECATED; } else if ("Synthetic".equals(attrName)) { @@ -592,6 +597,9 @@ public void accept(final ClassVisitor classVisitor, } else if (ANNOTATIONS && "RuntimeInvisibleAnnotations".equals(attrName)) { ianns = u + 8; + } else if (ANNOTATIONS + && "RuntimeInvisibleTypeAnnotations".equals(attrName)) { + itanns = u + 8; } else if ("BootstrapMethods".equals(attrName)) { int[] bootstrapMethods = new int[readUnsignedShort(u + 8)]; for (int j = 0, v = u + 10; j < bootstrapMethods.length; j++) { @@ -626,7 +634,7 @@ public void accept(final ClassVisitor classVisitor, enclosingDesc); } - // visits the class annotations + // visits the class annotations and type annotations if (ANNOTATIONS && anns != 0) { for (int i = readUnsignedShort(anns), v = anns + 2; i > 0; --i) { v = readAnnotationValues(v + 2, c, true, @@ -639,6 +647,22 @@ public void accept(final ClassVisitor classVisitor, classVisitor.visitAnnotation(readUTF8(v, c), false)); } } + if (ANNOTATIONS && tanns != 0) { + for (int i = readUnsignedShort(tanns), v = tanns + 2; i > 0; --i) { + v = readAnnotationTarget(context, v); + v = readAnnotationValues(v + 2, c, true, + classVisitor.visitTypeAnnotation(context.typeRef, + context.typePath, readUTF8(v, c), true)); + } + } + if (ANNOTATIONS && itanns != 0) { + for (int i = readUnsignedShort(itanns), v = itanns + 2; i > 0; --i) { + v = readAnnotationTarget(context, v); + v = readAnnotationValues(v + 2, c, true, + classVisitor.visitTypeAnnotation(context.typeRef, + context.typePath, readUTF8(v, c), false)); + } + } // visits the attributes while (attributes != null) { @@ -697,6 +721,8 @@ private int readField(final ClassVisitor classVisitor, String signature = null; int anns = 0; int ianns = 0; + int tanns = 0; + int itanns = 0; Object value = null; Attribute attributes = null; @@ -717,9 +743,15 @@ private int readField(final ClassVisitor classVisitor, } else if (ANNOTATIONS && "RuntimeVisibleAnnotations".equals(attrName)) { anns = u + 8; + } else if (ANNOTATIONS + && "RuntimeVisibleTypeAnnotations".equals(attrName)) { + tanns = u + 8; } else if (ANNOTATIONS && "RuntimeInvisibleAnnotations".equals(attrName)) { ianns = u + 8; + } else if (ANNOTATIONS + && "RuntimeInvisibleTypeAnnotations".equals(attrName)) { + itanns = u + 8; } else { Attribute attr = readAttribute(context.attrs, attrName, u + 8, readInt(u + 4), c, -1, null); @@ -739,7 +771,7 @@ private int readField(final ClassVisitor classVisitor, return u; } - // visits the field annotations + // visits the field annotations and type annotations if (ANNOTATIONS && anns != 0) { for (int i = readUnsignedShort(anns), v = anns + 2; i > 0; --i) { v = readAnnotationValues(v + 2, c, true, @@ -752,6 +784,22 @@ private int readField(final ClassVisitor classVisitor, fv.visitAnnotation(readUTF8(v, c), false)); } } + if (ANNOTATIONS && tanns != 0) { + for (int i = readUnsignedShort(tanns), v = tanns + 2; i > 0; --i) { + v = readAnnotationTarget(context, v); + v = readAnnotationValues(v + 2, c, true, + fv.visitTypeAnnotation(context.typeRef, + context.typePath, readUTF8(v, c), true)); + } + } + if (ANNOTATIONS && itanns != 0) { + for (int i = readUnsignedShort(itanns), v = itanns + 2; i > 0; --i) { + v = readAnnotationTarget(context, v); + v = readAnnotationValues(v + 2, c, true, + fv.visitTypeAnnotation(context.typeRef, + context.typePath, readUTF8(v, c), false)); + } + } // visits the field attributes while (attributes != null) { @@ -782,9 +830,9 @@ private int readMethod(final ClassVisitor classVisitor, final Context context, int u) { // reads the method declaration char[] c = context.buffer; - int access = readUnsignedShort(u); - String name = readUTF8(u + 2, c); - String desc = readUTF8(u + 4, c); + context.access = readUnsignedShort(u); + context.name = readUTF8(u + 2, c); + context.desc = readUTF8(u + 4, c); u += 6; // reads the method attributes @@ -792,8 +840,11 @@ private int readMethod(final ClassVisitor classVisitor, int exception = 0; String[] exceptions = null; String signature = null; + int methodParameters = 0; int anns = 0; int ianns = 0; + int tanns = 0; + int itanns = 0; int dann = 0; int mpanns = 0; int impanns = 0; @@ -818,24 +869,32 @@ private int readMethod(final ClassVisitor classVisitor, } else if (SIGNATURES && "Signature".equals(attrName)) { signature = readUTF8(u + 8, c); } else if ("Deprecated".equals(attrName)) { - access |= Opcodes.ACC_DEPRECATED; + context.access |= Opcodes.ACC_DEPRECATED; } else if (ANNOTATIONS && "RuntimeVisibleAnnotations".equals(attrName)) { anns = u + 8; + } else if (ANNOTATIONS + && "RuntimeVisibleTypeAnnotations".equals(attrName)) { + tanns = u + 8; } else if (ANNOTATIONS && "AnnotationDefault".equals(attrName)) { dann = u + 8; } else if ("Synthetic".equals(attrName)) { - access |= Opcodes.ACC_SYNTHETIC + context.access |= Opcodes.ACC_SYNTHETIC | ClassWriter.ACC_SYNTHETIC_ATTRIBUTE; } else if (ANNOTATIONS && "RuntimeInvisibleAnnotations".equals(attrName)) { ianns = u + 8; + } else if (ANNOTATIONS + && "RuntimeInvisibleTypeAnnotations".equals(attrName)) { + itanns = u + 8; } else if (ANNOTATIONS && "RuntimeVisibleParameterAnnotations".equals(attrName)) { mpanns = u + 8; } else if (ANNOTATIONS && "RuntimeInvisibleParameterAnnotations".equals(attrName)) { impanns = u + 8; + } else if ("MethodParameters".equals(attrName)) { + methodParameters = u + 8; } else { Attribute attr = readAttribute(context.attrs, attrName, u + 8, readInt(u + 4), c, -1, null); @@ -849,8 +908,8 @@ private int readMethod(final ClassVisitor classVisitor, u += 2; // visits the method declaration - MethodVisitor mv = classVisitor.visitMethod(access, name, desc, - signature, exceptions); + MethodVisitor mv = classVisitor.visitMethod(context.access, + context.name, context.desc, signature, exceptions); if (mv == null) { return u; } @@ -894,6 +953,13 @@ private int readMethod(final ClassVisitor classVisitor, } } + // visit the method parameters + if (methodParameters != 0) { + for (int i = b[methodParameters] & 0xFF, v = methodParameters + 1; i > 0; --i, v = v + 4) { + mv.visitParameter(readUTF8(v, c), readUnsignedShort(v + 2)); + } + } + // visits the method annotations if (ANNOTATIONS && dann != 0) { AnnotationVisitor dv = mv.visitAnnotationDefault(); @@ -914,11 +980,27 @@ private int readMethod(final ClassVisitor classVisitor, mv.visitAnnotation(readUTF8(v, c), false)); } } + if (ANNOTATIONS && tanns != 0) { + for (int i = readUnsignedShort(tanns), v = tanns + 2; i > 0; --i) { + v = readAnnotationTarget(context, v); + v = readAnnotationValues(v + 2, c, true, + mv.visitTypeAnnotation(context.typeRef, + context.typePath, readUTF8(v, c), true)); + } + } + if (ANNOTATIONS && itanns != 0) { + for (int i = readUnsignedShort(itanns), v = itanns + 2; i > 0; --i) { + v = readAnnotationTarget(context, v); + v = readAnnotationValues(v + 2, c, true, + mv.visitTypeAnnotation(context.typeRef, + context.typePath, readUTF8(v, c), false)); + } + } if (ANNOTATIONS && mpanns != 0) { - readParameterAnnotations(mpanns, desc, c, true, mv); + readParameterAnnotations(mv, context, mpanns, true); } if (ANNOTATIONS && impanns != 0) { - readParameterAnnotations(impanns, desc, c, false, mv); + readParameterAnnotations(mv, context, impanns, false); } // visits the method attributes @@ -931,9 +1013,6 @@ private int readMethod(final ClassVisitor classVisitor, // visits the method code if (code != 0) { - context.access = access; - context.name = name; - context.desc = desc; mv.visitCode(); readCode(mv, context, code); } @@ -966,7 +1045,7 @@ private void readCode(final MethodVisitor mv, final Context context, int u) { // reads the bytecode to find the labels int codeStart = u; int codeEnd = u + codeLength; - Label[] labels = new Label[codeLength + 2]; + Label[] labels = context.labels = new Label[codeLength + 2]; readLabel(codeLength + 1, labels); while (u < codeEnd) { int offset = u - codeStart; @@ -1049,6 +1128,12 @@ private void readCode(final MethodVisitor mv, final Context context, int u) { u += 2; // reads the code attributes + int[] tanns = null; // start index of each visible type annotation + int[] itanns = null; // start index of each invisible type annotation + int tann = 0; // current index in tanns array + int itann = 0; // current index in itanns array + int ntoff = -1; // next visible type annotation code offset + int nitoff = -1; // next invisible type annotation code offset int varTable = 0; int varTypeTable = 0; boolean zip = true; @@ -1089,6 +1174,16 @@ private void readCode(final MethodVisitor mv, final Context context, int u) { v += 4; } } + } else if (ANNOTATIONS + && "RuntimeVisibleTypeAnnotations".equals(attrName)) { + tanns = readTypeAnnotations(mv, context, u + 8, true); + ntoff = tanns.length == 0 || readByte(tanns[0]) < 0x43 ? -1 + : readUnsignedShort(tanns[0] + 1); + } else if (ANNOTATIONS + && "RuntimeInvisibleTypeAnnotations".equals(attrName)) { + itanns = readTypeAnnotations(mv, context, u + 8, false); + nitoff = itanns.length == 0 || readByte(itanns[0]) < 0x43 ? -1 + : readUnsignedShort(itanns[0] + 1); } else if (FRAMES && "StackMapTable".equals(attrName)) { if ((context.flags & SKIP_FRAMES) == 0) { stackMap = u + 10; @@ -1211,7 +1306,7 @@ private void readCode(final MethodVisitor mv, final Context context, int u) { } } if (frameCount > 0) { - stackMap = readFrame(stackMap, zip, unzip, labels, frame); + stackMap = readFrame(stackMap, zip, unzip, frame); --frameCount; } else { frame = null; @@ -1310,6 +1405,7 @@ private void readCode(final MethodVisitor mv, final Context context, int u) { case ClassWriter.FIELDORMETH_INSN: case ClassWriter.ITFMETH_INSN: { int cpIndex = items[readUnsignedShort(u + 1)]; + boolean itf = b[cpIndex - 1] == ClassWriter.IMETH; String iowner = readClass(cpIndex, c); cpIndex = items[readUnsignedShort(cpIndex + 2)]; String iname = readUTF8(cpIndex, c); @@ -1317,7 +1413,7 @@ private void readCode(final MethodVisitor mv, final Context context, int u) { if (opcode < Opcodes.INVOKEVIRTUAL) { mv.visitFieldInsn(opcode, iowner, iname, idesc); } else { - mv.visitMethodInsn(opcode, iowner, iname, idesc); + mv.visitMethodInsn(opcode, iowner, iname, idesc, itf); } if (opcode == Opcodes.INVOKEINTERFACE) { u += 5; @@ -1358,6 +1454,29 @@ private void readCode(final MethodVisitor mv, final Context context, int u) { u += 4; break; } + + // visit the instruction annotations, if any + while (tanns != null && tann < tanns.length && ntoff <= offset) { + if (ntoff == offset) { + int v = readAnnotationTarget(context, tanns[tann]); + readAnnotationValues(v + 2, c, true, + mv.visitInsnAnnotation(context.typeRef, + context.typePath, readUTF8(v, c), true)); + } + ntoff = ++tann >= tanns.length || readByte(tanns[tann]) < 0x43 ? -1 + : readUnsignedShort(tanns[tann] + 1); + } + while (itanns != null && itann < itanns.length && nitoff <= offset) { + if (nitoff == offset) { + int v = readAnnotationTarget(context, itanns[itann]); + readAnnotationValues(v + 2, c, true, + mv.visitInsnAnnotation(context.typeRef, + context.typePath, readUTF8(v, c), false)); + } + nitoff = ++itann >= itanns.length + || readByte(itanns[itann]) < 0x43 ? -1 + : readUnsignedShort(itanns[itann] + 1); + } } if (labels[codeLength] != null) { mv.visitLabel(labels[codeLength]); @@ -1397,6 +1516,32 @@ private void readCode(final MethodVisitor mv, final Context context, int u) { } } + // visits the local variables type annotations + if (tanns != null) { + for (int i = 0; i < tanns.length; ++i) { + if ((readByte(tanns[i]) >> 1) == (0x40 >> 1)) { + int v = readAnnotationTarget(context, tanns[i]); + v = readAnnotationValues(v + 2, c, true, + mv.visitLocalVariableAnnotation(context.typeRef, + context.typePath, context.start, + context.end, context.index, readUTF8(v, c), + true)); + } + } + } + if (itanns != null) { + for (int i = 0; i < itanns.length; ++i) { + if ((readByte(itanns[i]) >> 1) == (0x40 >> 1)) { + int v = readAnnotationTarget(context, itanns[i]); + v = readAnnotationValues(v + 2, c, true, + mv.visitLocalVariableAnnotation(context.typeRef, + context.typePath, context.start, + context.end, context.index, readUTF8(v, c), + false)); + } + } + } + // visits the code attributes while (attributes != null) { Attribute attr = attributes.next; @@ -1409,25 +1554,176 @@ private void readCode(final MethodVisitor mv, final Context context, int u) { mv.visitMaxs(maxStack, maxLocals); } + /** + * Parses a type annotation table to find the labels, and to visit the try + * catch block annotations. + * + * @param u + * the start offset of a type annotation table. + * @param mv + * the method visitor to be used to visit the try catch block + * annotations. + * @param context + * information about the class being parsed. + * @param visible + * if the type annotation table to parse contains runtime visible + * annotations. + * @return the start offset of each type annotation in the parsed table. + */ + private int[] readTypeAnnotations(final MethodVisitor mv, + final Context context, int u, boolean visible) { + char[] c = context.buffer; + int[] offsets = new int[readUnsignedShort(u)]; + u += 2; + for (int i = 0; i < offsets.length; ++i) { + offsets[i] = u; + int target = readInt(u); + switch (target >>> 24) { + case 0x00: // CLASS_TYPE_PARAMETER + case 0x01: // METHOD_TYPE_PARAMETER + case 0x16: // METHOD_FORMAL_PARAMETER + u += 2; + break; + case 0x13: // FIELD + case 0x14: // METHOD_RETURN + case 0x15: // METHOD_RECEIVER + u += 1; + break; + case 0x40: // LOCAL_VARIABLE + case 0x41: // RESOURCE_VARIABLE + for (int j = readUnsignedShort(u + 1); j > 0; --j) { + int start = readUnsignedShort(u + 3); + int length = readUnsignedShort(u + 5); + readLabel(start, context.labels); + readLabel(start + length, context.labels); + u += 6; + } + u += 3; + break; + case 0x47: // CAST + case 0x48: // CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT + case 0x49: // METHOD_INVOCATION_TYPE_ARGUMENT + case 0x4A: // CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT + case 0x4B: // METHOD_REFERENCE_TYPE_ARGUMENT + u += 4; + break; + // case 0x10: // CLASS_EXTENDS + // case 0x11: // CLASS_TYPE_PARAMETER_BOUND + // case 0x12: // METHOD_TYPE_PARAMETER_BOUND + // case 0x17: // THROWS + // case 0x42: // EXCEPTION_PARAMETER + // case 0x43: // INSTANCEOF + // case 0x44: // NEW + // case 0x45: // CONSTRUCTOR_REFERENCE + // case 0x46: // METHOD_REFERENCE + default: + u += 3; + break; + } + int pathLength = readByte(u); + if ((target >>> 24) == 0x42) { + TypePath path = pathLength == 0 ? null : new TypePath(b, u); + u += 1 + 2 * pathLength; + u = readAnnotationValues(u + 2, c, true, + mv.visitTryCatchAnnotation(target, path, + readUTF8(u, c), visible)); + } else { + u = readAnnotationValues(u + 3 + 2 * pathLength, c, true, null); + } + } + return offsets; + } + + /** + * Parses the header of a type annotation to extract its target_type and + * target_path (the result is stored in the given context), and returns the + * start offset of the rest of the type_annotation structure (i.e. the + * offset to the type_index field, which is followed by + * num_element_value_pairs and then the name,value pairs). + * + * @param context + * information about the class being parsed. This is where the + * extracted target_type and target_path must be stored. + * @param u + * the start offset of a type_annotation structure. + * @return the start offset of the rest of the type_annotation structure. + */ + private int readAnnotationTarget(final Context context, int u) { + int target = readInt(u); + switch (target >>> 24) { + case 0x00: // CLASS_TYPE_PARAMETER + case 0x01: // METHOD_TYPE_PARAMETER + case 0x16: // METHOD_FORMAL_PARAMETER + target &= 0xFFFF0000; + u += 2; + break; + case 0x13: // FIELD + case 0x14: // METHOD_RETURN + case 0x15: // METHOD_RECEIVER + target &= 0xFF000000; + u += 1; + break; + case 0x40: // LOCAL_VARIABLE + case 0x41: { // RESOURCE_VARIABLE + target &= 0xFF000000; + int n = readUnsignedShort(u + 1); + context.start = new Label[n]; + context.end = new Label[n]; + context.index = new int[n]; + u += 3; + for (int i = 0; i < n; ++i) { + int start = readUnsignedShort(u); + int length = readUnsignedShort(u + 2); + context.start[i] = readLabel(start, context.labels); + context.end[i] = readLabel(start + length, context.labels); + context.index[i] = readUnsignedShort(u + 4); + u += 6; + } + break; + } + case 0x47: // CAST + case 0x48: // CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT + case 0x49: // METHOD_INVOCATION_TYPE_ARGUMENT + case 0x4A: // CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT + case 0x4B: // METHOD_REFERENCE_TYPE_ARGUMENT + target &= 0xFF0000FF; + u += 4; + break; + // case 0x10: // CLASS_EXTENDS + // case 0x11: // CLASS_TYPE_PARAMETER_BOUND + // case 0x12: // METHOD_TYPE_PARAMETER_BOUND + // case 0x17: // THROWS + // case 0x42: // EXCEPTION_PARAMETER + // case 0x43: // INSTANCEOF + // case 0x44: // NEW + // case 0x45: // CONSTRUCTOR_REFERENCE + // case 0x46: // METHOD_REFERENCE + default: + target &= (target >>> 24) < 0x43 ? 0xFFFFFF00 : 0xFF000000; + u += 3; + break; + } + int pathLength = readByte(u); + context.typeRef = target; + context.typePath = pathLength == 0 ? null : new TypePath(b, u); + return u + 1 + 2 * pathLength; + } + /** * Reads parameter annotations and makes the given visitor visit them. * + * @param mv + * the visitor that must visit the annotations. + * @param context + * information about the class being parsed. * @param v * start offset in {@link #b b} of the annotations to be read. - * @param desc - * the method descriptor. - * @param buf - * buffer to be used to call {@link #readUTF8 readUTF8}, - * {@link #readClass(int,char[]) readClass} or {@link #readConst - * readConst}. * @param visible * true if the annotations to be read are visible at * runtime. - * @param mv - * the visitor that must visit the annotations. */ - private void readParameterAnnotations(int v, final String desc, - final char[] buf, final boolean visible, final MethodVisitor mv) { + private void readParameterAnnotations(final MethodVisitor mv, + final Context context, int v, final boolean visible) { int i; int n = b[v++] & 0xFF; // workaround for a bug in javac (javac compiler generates a parameter @@ -1436,7 +1732,7 @@ private void readParameterAnnotations(int v, final String desc, // equal to the number of parameters in the method descriptor - which // includes the synthetic parameters added by the compiler). This work- // around supposes that the synthetic parameters are the first ones. - int synthetics = Type.getArgumentTypes(desc).length - n; + int synthetics = Type.getArgumentTypes(context.desc).length - n; AnnotationVisitor av; for (i = 0; i < synthetics; ++i) { // virtual annotation to detect synthetic parameters in MethodWriter @@ -1445,12 +1741,13 @@ private void readParameterAnnotations(int v, final String desc, av.visitEnd(); } } + char[] c = context.buffer; for (; i < n + synthetics; ++i) { int j = readUnsignedShort(v); v += 2; for (; j > 0; --j) { - av = mv.visitParameterAnnotation(i, readUTF8(v, buf), visible); - v = readAnnotationValues(v + 2, buf, true, av); + av = mv.visitParameterAnnotation(i, readUTF8(v, c), visible); + v = readAnnotationValues(v + 2, c, true, av); } } } @@ -1729,17 +2026,14 @@ private void getImplicitFrame(final Context frame) { * if the stack map frame at stackMap is compressed or not. * @param unzip * if the stack map frame must be uncompressed. - * @param labels - * the labels of the method currently being parsed, indexed by - * their offset. A new label for the parsed stack map frame is - * stored in this array if it does not already exist. * @param frame * where the parsed stack map frame must be stored. * @return the offset of the first byte following the parsed frame. */ private int readFrame(int stackMap, boolean zip, boolean unzip, - Label[] labels, Context frame) { + Context frame) { char[] c = frame.buffer; + Label[] labels = frame.labels; int tag; int delta; if (zip) { diff --git a/src/asm/scala/tools/asm/ClassVisitor.java b/src/asm/scala/tools/asm/ClassVisitor.java index 3fc364d5e5b6..48dc2ca6ae4d 100644 --- a/src/asm/scala/tools/asm/ClassVisitor.java +++ b/src/asm/scala/tools/asm/ClassVisitor.java @@ -33,8 +33,9 @@ * A visitor to visit a Java class. The methods of this class must be called in * the following order: visit [ visitSource ] [ * visitOuterClass ] ( visitAnnotation | - * visitAttribute )* ( visitInnerClass | visitField | - * visitMethod )* visitEnd. + * visitTypeAnnotation | visitAttribute )* ( + * visitInnerClass | visitField | visitMethod )* + * visitEnd. * * @author Eric Bruneton */ @@ -42,7 +43,7 @@ public abstract class ClassVisitor { /** * The ASM API version implemented by this visitor. The value of this field - * must be one of {@link Opcodes#ASM4}. + * must be one of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. */ protected final int api; @@ -57,7 +58,7 @@ public abstract class ClassVisitor { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. */ public ClassVisitor(final int api) { this(api, null); @@ -68,13 +69,13 @@ public ClassVisitor(final int api) { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. * @param cv * the class visitor to which this visitor must delegate method * calls. May be null. */ public ClassVisitor(final int api, final ClassVisitor cv) { - if (api != Opcodes.ASM4) { + if (api != Opcodes.ASM4 && api != Opcodes.ASM5) { throw new IllegalArgumentException(); } this.api = api; @@ -168,6 +169,39 @@ public AnnotationVisitor visitAnnotation(String desc, boolean visible) { return null; } + /** + * Visits an annotation on a type in the class signature. + * + * @param typeRef + * a reference to the annotated type. The sort of this type + * reference must be {@link TypeReference#CLASS_TYPE_PARAMETER + * CLASS_TYPE_PARAMETER}, + * {@link TypeReference#CLASS_TYPE_PARAMETER_BOUND + * CLASS_TYPE_PARAMETER_BOUND} or + * {@link TypeReference#CLASS_EXTENDS CLASS_EXTENDS}. See + * {@link TypeReference}. + * @param typePath + * the path to the annotated type argument, wildcard bound, array + * element type, or static inner type within 'typeRef'. May be + * null if the annotation targets 'typeRef' as a whole. + * @param desc + * the class descriptor of the annotation class. + * @param visible + * true if the annotation is visible at runtime. + * @return a visitor to visit the annotation values, or null if + * this visitor is not interested in visiting this annotation. + */ + public AnnotationVisitor visitTypeAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + if (api < Opcodes.ASM5) { + throw new RuntimeException(); + } + if (cv != null) { + return cv.visitTypeAnnotation(typeRef, typePath, desc, visible); + } + return null; + } + /** * Visits a non standard attribute of the class. * diff --git a/src/asm/scala/tools/asm/ClassWriter.java b/src/asm/scala/tools/asm/ClassWriter.java index 93ed7313c7c5..5c2de3f98228 100644 --- a/src/asm/scala/tools/asm/ClassWriter.java +++ b/src/asm/scala/tools/asm/ClassWriter.java @@ -416,6 +416,16 @@ public class ClassWriter extends ClassVisitor { */ private AnnotationWriter ianns; + /** + * The runtime visible type annotations of this class. + */ + private AnnotationWriter tanns; + + /** + * The runtime invisible type annotations of this class. + */ + private AnnotationWriter itanns; + /** * The non standard attributes of this class. */ @@ -477,12 +487,12 @@ public class ClassWriter extends ClassVisitor { * true if the maximum stack size and number of local variables * must be automatically computed. */ - private final boolean computeMaxs; + private boolean computeMaxs; /** * true if the stack map frames must be recomputed from scratch. */ - private final boolean computeFrames; + private boolean computeFrames; /** * true if the stack map tables of this class are invalid. The @@ -595,7 +605,7 @@ public class ClassWriter extends ClassVisitor { * {@link #COMPUTE_FRAMES}. */ public ClassWriter(final int flags) { - super(Opcodes.ASM4); + super(Opcodes.ASM5); index = 1; pool = new ByteVector(); items = new Item[256]; @@ -677,7 +687,8 @@ public final void visitSource(final String file, final String debug) { sourceFile = newUTF8(file); } if (debug != null) { - sourceDebug = new ByteVector().putUTF8(debug); + sourceDebug = new ByteVector().encodeUTF8(debug, 0, + Integer.MAX_VALUE); } } @@ -710,6 +721,29 @@ public final AnnotationVisitor visitAnnotation(final String desc, return aw; } + @Override + public final AnnotationVisitor visitTypeAnnotation(int typeRef, + TypePath typePath, final String desc, final boolean visible) { + if (!ClassReader.ANNOTATIONS) { + return null; + } + ByteVector bv = new ByteVector(); + // write target_type and target_info + AnnotationWriter.putTarget(typeRef, typePath, bv); + // write type, and reserve space for values count + bv.putShort(newUTF8(desc)).putShort(0); + AnnotationWriter aw = new AnnotationWriter(this, true, bv, bv, + bv.length - 2); + if (visible) { + aw.next = tanns; + tanns = aw; + } else { + aw.next = itanns; + itanns = aw; + } + return aw; + } + @Override public final void visitAttribute(final Attribute attr) { attr.next = attrs; @@ -722,11 +756,29 @@ public final void visitInnerClass(final String name, if (innerClasses == null) { innerClasses = new ByteVector(); } - ++innerClassesCount; - innerClasses.putShort(name == null ? 0 : newClass(name)); - innerClasses.putShort(outerName == null ? 0 : newClass(outerName)); - innerClasses.putShort(innerName == null ? 0 : newUTF8(innerName)); - innerClasses.putShort(access); + // Sec. 4.7.6 of the JVMS states "Every CONSTANT_Class_info entry in the + // constant_pool table which represents a class or interface C that is + // not a package member must have exactly one corresponding entry in the + // classes array". To avoid duplicates we keep track in the intVal field + // of the Item of each CONSTANT_Class_info entry C whether an inner + // class entry has already been added for C (this field is unused for + // class entries, and changing its value does not change the hashcode + // and equality tests). If so we store the index of this inner class + // entry (plus one) in intVal. This hack allows duplicate detection in + // O(1) time. + Item nameItem = newClassItem(name); + if (nameItem.intVal == 0) { + ++innerClassesCount; + innerClasses.putShort(nameItem.index); + innerClasses.putShort(outerName == null ? 0 : newClass(outerName)); + innerClasses.putShort(innerName == null ? 0 : newUTF8(innerName)); + innerClasses.putShort(access); + nameItem.intVal = innerClassesCount; + } else { + // Compare the inner classes entry nameItem.intVal - 1 with the + // arguments of this method and throw an exception if there is a + // difference? + } } @Override @@ -795,7 +847,7 @@ public byte[] toByteArray() { } if (sourceDebug != null) { ++attributeCount; - size += sourceDebug.length + 4; + size += sourceDebug.length + 6; newUTF8("SourceDebugExtension"); } if (enclosingMethodOwner != 0) { @@ -831,6 +883,16 @@ public byte[] toByteArray() { size += 8 + ianns.getSize(); newUTF8("RuntimeInvisibleAnnotations"); } + if (ClassReader.ANNOTATIONS && tanns != null) { + ++attributeCount; + size += 8 + tanns.getSize(); + newUTF8("RuntimeVisibleTypeAnnotations"); + } + if (ClassReader.ANNOTATIONS && itanns != null) { + ++attributeCount; + size += 8 + itanns.getSize(); + newUTF8("RuntimeInvisibleTypeAnnotations"); + } if (attrs != null) { attributeCount += attrs.getCount(); size += attrs.getSize(this, null, 0, -1, -1); @@ -874,9 +936,9 @@ public byte[] toByteArray() { out.putShort(newUTF8("SourceFile")).putInt(2).putShort(sourceFile); } if (sourceDebug != null) { - int len = sourceDebug.length - 2; + int len = sourceDebug.length; out.putShort(newUTF8("SourceDebugExtension")).putInt(len); - out.putByteArray(sourceDebug.data, 2, len); + out.putByteArray(sourceDebug.data, 0, len); } if (enclosingMethodOwner != 0) { out.putShort(newUTF8("EnclosingMethod")).putInt(4); @@ -904,13 +966,34 @@ public byte[] toByteArray() { out.putShort(newUTF8("RuntimeInvisibleAnnotations")); ianns.put(out); } + if (ClassReader.ANNOTATIONS && tanns != null) { + out.putShort(newUTF8("RuntimeVisibleTypeAnnotations")); + tanns.put(out); + } + if (ClassReader.ANNOTATIONS && itanns != null) { + out.putShort(newUTF8("RuntimeInvisibleTypeAnnotations")); + itanns.put(out); + } if (attrs != null) { attrs.put(this, null, 0, -1, -1, out); } if (invalidFrames) { - ClassWriter cw = new ClassWriter(COMPUTE_FRAMES); - new ClassReader(out.data).accept(cw, ClassReader.SKIP_FRAMES); - return cw.toByteArray(); + anns = null; + ianns = null; + attrs = null; + innerClassesCount = 0; + innerClasses = null; + bootstrapMethodsCount = 0; + bootstrapMethods = null; + firstField = null; + lastField = null; + firstMethod = null; + lastMethod = null; + computeMaxs = false; + computeFrames = true; + invalidFrames = false; + new ClassReader(out.data).accept(this, ClassReader.SKIP_FRAMES); + return toByteArray(); } return out.data; } @@ -1577,7 +1660,7 @@ int getMergedType(final int type1, final int type2) { /** * Returns the common super type of the two given types. The default - * implementation of this method loads the two given classes and uses + * implementation of this method loads the two given classes and uses * the java.lang.Class methods to find the common super class. It can be * overridden to compute this common super type in other ways, in particular * without actually loading any class, or to take into account the class @@ -1663,6 +1746,15 @@ private void put(final Item i) { items[index] = i; } + /** + * Find item that whose index is `index`. + */ + public Item findItemByIndex(int index) { + int i = 0; + while (i < items.length && (items[i] == null || items[i].index != index)) i++; + return items[i]; + } + /** * Puts one byte and two shorts into the constant pool. * diff --git a/src/asm/scala/tools/asm/Context.java b/src/asm/scala/tools/asm/Context.java index 7b3a2ad9dd38..24546969e38e 100644 --- a/src/asm/scala/tools/asm/Context.java +++ b/src/asm/scala/tools/asm/Context.java @@ -72,11 +72,46 @@ class Context { */ String desc; + /** + * The label objects, indexed by bytecode offset, of the method currently + * being parsed (only bytecode offsets for which a label is needed have a + * non null associated Label object). + */ + Label[] labels; + + /** + * The target of the type annotation currently being parsed. + */ + int typeRef; + + /** + * The path of the type annotation currently being parsed. + */ + TypePath typePath; + /** * The offset of the latest stack map frame that has been parsed. */ int offset; + /** + * The labels corresponding to the start of the local variable ranges in the + * local variable type annotation currently being parsed. + */ + Label[] start; + + /** + * The labels corresponding to the end of the local variable ranges in the + * local variable type annotation currently being parsed. + */ + Label[] end; + + /** + * The local variable indices for each local variable range in the local + * variable type annotation currently being parsed. + */ + int[] index; + /** * The encoding of the latest stack map frame that has been parsed. */ diff --git a/src/asm/scala/tools/asm/CustomAttr.java b/src/asm/scala/tools/asm/CustomAttr.java index 22b5d287b7c9..5ecfd283d058 100644 --- a/src/asm/scala/tools/asm/CustomAttr.java +++ b/src/asm/scala/tools/asm/CustomAttr.java @@ -1,5 +1,5 @@ /* NSC -- new Scala compiler - * Copyright 2005-2013 LAMP/EPFL + * Copyright 2005-2012 LAMP/EPFL */ package scala.tools.asm; diff --git a/src/asm/scala/tools/asm/FieldVisitor.java b/src/asm/scala/tools/asm/FieldVisitor.java index 9171f331e5ad..708c1d322e34 100644 --- a/src/asm/scala/tools/asm/FieldVisitor.java +++ b/src/asm/scala/tools/asm/FieldVisitor.java @@ -31,8 +31,8 @@ /** * A visitor to visit a Java field. The methods of this class must be called in - * the following order: ( visitAnnotation | visitAttribute )* - * visitEnd. + * the following order: ( visitAnnotation | + * visitTypeAnnotation | visitAttribute )* visitEnd. * * @author Eric Bruneton */ @@ -40,7 +40,7 @@ public abstract class FieldVisitor { /** * The ASM API version implemented by this visitor. The value of this field - * must be one of {@link Opcodes#ASM4}. + * must be one of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. */ protected final int api; @@ -55,7 +55,7 @@ public abstract class FieldVisitor { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. */ public FieldVisitor(final int api) { this(api, null); @@ -66,13 +66,13 @@ public FieldVisitor(final int api) { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. * @param fv * the field visitor to which this visitor must delegate method * calls. May be null. */ public FieldVisitor(final int api, final FieldVisitor fv) { - if (api != Opcodes.ASM4) { + if (api != Opcodes.ASM4 && api != Opcodes.ASM5) { throw new IllegalArgumentException(); } this.api = api; @@ -96,6 +96,35 @@ public AnnotationVisitor visitAnnotation(String desc, boolean visible) { return null; } + /** + * Visits an annotation on the type of the field. + * + * @param typeRef + * a reference to the annotated type. The sort of this type + * reference must be {@link TypeReference#FIELD FIELD}. See + * {@link TypeReference}. + * @param typePath + * the path to the annotated type argument, wildcard bound, array + * element type, or static inner type within 'typeRef'. May be + * null if the annotation targets 'typeRef' as a whole. + * @param desc + * the class descriptor of the annotation class. + * @param visible + * true if the annotation is visible at runtime. + * @return a visitor to visit the annotation values, or null if + * this visitor is not interested in visiting this annotation. + */ + public AnnotationVisitor visitTypeAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + if (api < Opcodes.ASM5) { + throw new RuntimeException(); + } + if (fv != null) { + return fv.visitTypeAnnotation(typeRef, typePath, desc, visible); + } + return null; + } + /** * Visits a non standard attribute of the field. * diff --git a/src/asm/scala/tools/asm/FieldWriter.java b/src/asm/scala/tools/asm/FieldWriter.java index 02c6059b9149..e640a8d4060b 100644 --- a/src/asm/scala/tools/asm/FieldWriter.java +++ b/src/asm/scala/tools/asm/FieldWriter.java @@ -80,6 +80,17 @@ final class FieldWriter extends FieldVisitor { */ private AnnotationWriter ianns; + /** + * The runtime visible type annotations of this field. May be null. + */ + private AnnotationWriter tanns; + + /** + * The runtime invisible type annotations of this field. May be + * null. + */ + private AnnotationWriter itanns; + /** * The non standard attributes of this field. May be null. */ @@ -107,7 +118,7 @@ final class FieldWriter extends FieldVisitor { */ FieldWriter(final ClassWriter cw, final int access, final String name, final String desc, final String signature, final Object value) { - super(Opcodes.ASM4); + super(Opcodes.ASM5); if (cw.firstField == null) { cw.firstField = this; } else { @@ -150,6 +161,29 @@ public AnnotationVisitor visitAnnotation(final String desc, return aw; } + @Override + public AnnotationVisitor visitTypeAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + if (!ClassReader.ANNOTATIONS) { + return null; + } + ByteVector bv = new ByteVector(); + // write target_type and target_info + AnnotationWriter.putTarget(typeRef, typePath, bv); + // write type, and reserve space for values count + bv.putShort(cw.newUTF8(desc)).putShort(0); + AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, + bv.length - 2); + if (visible) { + aw.next = tanns; + tanns = aw; + } else { + aw.next = itanns; + itanns = aw; + } + return aw; + } + @Override public void visitAttribute(final Attribute attr) { attr.next = attrs; @@ -198,6 +232,14 @@ int getSize() { cw.newUTF8("RuntimeInvisibleAnnotations"); size += 8 + ianns.getSize(); } + if (ClassReader.ANNOTATIONS && tanns != null) { + cw.newUTF8("RuntimeVisibleTypeAnnotations"); + size += 8 + tanns.getSize(); + } + if (ClassReader.ANNOTATIONS && itanns != null) { + cw.newUTF8("RuntimeInvisibleTypeAnnotations"); + size += 8 + itanns.getSize(); + } if (attrs != null) { size += attrs.getSize(cw, null, 0, -1, -1); } @@ -237,6 +279,12 @@ void put(final ByteVector out) { if (ClassReader.ANNOTATIONS && ianns != null) { ++attributeCount; } + if (ClassReader.ANNOTATIONS && tanns != null) { + ++attributeCount; + } + if (ClassReader.ANNOTATIONS && itanns != null) { + ++attributeCount; + } if (attrs != null) { attributeCount += attrs.getCount(); } @@ -266,6 +314,14 @@ void put(final ByteVector out) { out.putShort(cw.newUTF8("RuntimeInvisibleAnnotations")); ianns.put(out); } + if (ClassReader.ANNOTATIONS && tanns != null) { + out.putShort(cw.newUTF8("RuntimeVisibleTypeAnnotations")); + tanns.put(out); + } + if (ClassReader.ANNOTATIONS && itanns != null) { + out.putShort(cw.newUTF8("RuntimeInvisibleTypeAnnotations")); + itanns.put(out); + } if (attrs != null) { attrs.put(cw, null, 0, -1, -1, out); } diff --git a/src/asm/scala/tools/asm/Frame.java b/src/asm/scala/tools/asm/Frame.java index bcc3e8450b66..85ad3269ab21 100644 --- a/src/asm/scala/tools/asm/Frame.java +++ b/src/asm/scala/tools/asm/Frame.java @@ -70,8 +70,8 @@ final class Frame { * stack types. VALUE depends on KIND. For LOCAL types, it is an index in * the input local variable types. For STACK types, it is a position * relatively to the top of input frame stack. For BASE types, it is either - * one of the constants defined in FrameVisitor, or for OBJECT and - * UNINITIALIZED types, a tag and an index in the type table. + * one of the constants defined below, or for OBJECT and UNINITIALIZED + * types, a tag and an index in the type table. * * Output frames can contain types of any kind and with a positive or * negative dimension (and even unassigned types, represented by 0 - which @@ -1417,6 +1417,7 @@ private static boolean merge(final ClassWriter cw, int t, // if t is the NULL type, merge(u,t)=u, so there is no change return false; } else if ((t & (DIM | BASE_KIND)) == (u & (DIM | BASE_KIND))) { + // if t and u have the same dimension and same base kind if ((u & BASE_KIND) == OBJECT) { // if t is also a reference type, and if u and t have the // same dimension merge(u,t) = dim(t) | common parent of the @@ -1425,13 +1426,21 @@ private static boolean merge(final ClassWriter cw, int t, | cw.getMergedType(t & BASE_VALUE, u & BASE_VALUE); } else { // if u and t are array types, but not with the same element - // type, merge(u,t)=java/lang/Object - v = OBJECT | cw.addType("java/lang/Object"); + // type, merge(u,t) = dim(u) - 1 | java/lang/Object + int vdim = ELEMENT_OF + (u & DIM); + v = vdim | OBJECT | cw.addType("java/lang/Object"); } } else if ((t & BASE_KIND) == OBJECT || (t & DIM) != 0) { - // if t is any other reference or array type, - // merge(u,t)=java/lang/Object - v = OBJECT | cw.addType("java/lang/Object"); + // if t is any other reference or array type, the merged type + // is min(udim, tdim) | java/lang/Object, where udim is the + // array dimension of u, minus 1 if u is an array type with a + // primitive element type (and similarly for tdim). + int tdim = (((t & DIM) == 0 || (t & BASE_KIND) == OBJECT) ? 0 + : ELEMENT_OF) + (t & DIM); + int udim = (((u & DIM) == 0 || (u & BASE_KIND) == OBJECT) ? 0 + : ELEMENT_OF) + (u & DIM); + v = Math.min(tdim, udim) | OBJECT + | cw.addType("java/lang/Object"); } else { // if t is any other type, merge(u,t)=TOP v = TOP; diff --git a/src/asm/scala/tools/asm/Handle.java b/src/asm/scala/tools/asm/Handle.java index 5dd06a54b953..cf12bb761332 100644 --- a/src/asm/scala/tools/asm/Handle.java +++ b/src/asm/scala/tools/asm/Handle.java @@ -49,7 +49,8 @@ public final class Handle { final int tag; /** - * The internal name of the field or method designed by this handle. + * The internal name of the class that owns the field or method designated + * by this handle. */ final String owner; @@ -76,8 +77,8 @@ public final class Handle { * {@link Opcodes#H_NEWINVOKESPECIAL} or * {@link Opcodes#H_INVOKEINTERFACE}. * @param owner - * the internal name of the field or method designed by this - * handle. + * the internal name of the class that owns the field or method + * designated by this handle. * @param name * the name of the field or method designated by this handle. * @param desc @@ -106,9 +107,11 @@ public int getTag() { } /** - * Returns the internal name of the field or method designed by this handle. + * Returns the internal name of the class that owns the field or method + * designated by this handle. * - * @return the internal name of the field or method designed by this handle. + * @return the internal name of the class that owns the field or method + * designated by this handle. */ public String getOwner() { return owner; diff --git a/src/asm/scala/tools/asm/Item.java b/src/asm/scala/tools/asm/Item.java index 94195a1082ee..4693f5ae9927 100644 --- a/src/asm/scala/tools/asm/Item.java +++ b/src/asm/scala/tools/asm/Item.java @@ -208,9 +208,10 @@ void set(final int type, final String strVal1, final String strVal2, this.strVal2 = strVal2; this.strVal3 = strVal3; switch (type) { + case ClassWriter.CLASS: + this.intVal = 0; // intVal of a class must be zero, see visitInnerClass case ClassWriter.UTF8: case ClassWriter.STR: - case ClassWriter.CLASS: case ClassWriter.MTYPE: case ClassWriter.TYPE_NORMAL: hashCode = 0x7FFFFFFF & (type + strVal1.hashCode()); diff --git a/src/asm/scala/tools/asm/MethodVisitor.java b/src/asm/scala/tools/asm/MethodVisitor.java index e43ca9782351..bddc325020dc 100644 --- a/src/asm/scala/tools/asm/MethodVisitor.java +++ b/src/asm/scala/tools/asm/MethodVisitor.java @@ -31,18 +31,24 @@ /** * A visitor to visit a Java method. The methods of this class must be called in - * the following order: [ visitAnnotationDefault ] ( - * visitAnnotation | visitParameterAnnotation | - * visitAttribute )* [ visitCode ( visitFrame | - * visitXInsn | visitLabel | - * visitTryCatchBlock | visitLocalVariable | + * the following order: ( visitParameter )* [ + * visitAnnotationDefault ] ( visitAnnotation | + * visitTypeAnnotation | visitAttribute )* [ + * visitCode ( visitFrame | visitXInsn | + * visitLabel | visitInsnAnnotation | + * visitTryCatchBlock | visitTryCatchBlockAnnotation | + * visitLocalVariable | visitLocalVariableAnnotation | * visitLineNumber )* visitMaxs ] visitEnd. In - * addition, the visitXInsn and visitLabel methods - * must be called in the sequential order of the bytecode instructions of the - * visited code, visitTryCatchBlock must be called before the - * labels passed as arguments have been visited, and the - * visitLocalVariable and visitLineNumber methods must be - * called after the labels passed as arguments have been visited. + * addition, the visitXInsn and visitLabel methods must + * be called in the sequential order of the bytecode instructions of the visited + * code, visitInsnAnnotation must be called after the annotated + * instruction, visitTryCatchBlock must be called before the + * labels passed as arguments have been visited, + * visitTryCatchBlockAnnotation must be called after the + * corresponding try catch block has been visited, and the + * visitLocalVariable, visitLocalVariableAnnotation and + * visitLineNumber methods must be called after the labels + * passed as arguments have been visited. * * @author Eric Bruneton */ @@ -50,7 +56,7 @@ public abstract class MethodVisitor { /** * The ASM API version implemented by this visitor. The value of this field - * must be one of {@link Opcodes#ASM4}. + * must be one of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. */ protected final int api; @@ -65,7 +71,7 @@ public abstract class MethodVisitor { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. */ public MethodVisitor(final int api) { this(api, null); @@ -76,13 +82,13 @@ public MethodVisitor(final int api) { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. * @param mv * the method visitor to which this visitor must delegate method * calls. May be null. */ public MethodVisitor(final int api, final MethodVisitor mv) { - if (api != Opcodes.ASM4) { + if (api != Opcodes.ASM4 && api != Opcodes.ASM5) { throw new IllegalArgumentException(); } this.api = api; @@ -90,9 +96,28 @@ public MethodVisitor(final int api, final MethodVisitor mv) { } // ------------------------------------------------------------------------- - // Annotations and non standard attributes + // Parameters, annotations and non standard attributes // ------------------------------------------------------------------------- + /** + * Visits a parameter of this method. + * + * @param name + * parameter name or null if none is provided. + * @param access + * the parameter's access flags, only ACC_FINAL, + * ACC_SYNTHETIC or/and ACC_MANDATED are + * allowed (see {@link Opcodes}). + */ + public void visitParameter(String name, int access) { + if (api < Opcodes.ASM5) { + throw new RuntimeException(); + } + if (mv != null) { + mv.visitParameter(name, access); + } + } + /** * Visits the default value of this annotation interface method. * @@ -127,6 +152,42 @@ public AnnotationVisitor visitAnnotation(String desc, boolean visible) { return null; } + /** + * Visits an annotation on a type in the method signature. + * + * @param typeRef + * a reference to the annotated type. The sort of this type + * reference must be {@link TypeReference#METHOD_TYPE_PARAMETER + * METHOD_TYPE_PARAMETER}, + * {@link TypeReference#METHOD_TYPE_PARAMETER_BOUND + * METHOD_TYPE_PARAMETER_BOUND}, + * {@link TypeReference#METHOD_RETURN METHOD_RETURN}, + * {@link TypeReference#METHOD_RECEIVER METHOD_RECEIVER}, + * {@link TypeReference#METHOD_FORMAL_PARAMETER + * METHOD_FORMAL_PARAMETER} or {@link TypeReference#THROWS + * THROWS}. See {@link TypeReference}. + * @param typePath + * the path to the annotated type argument, wildcard bound, array + * element type, or static inner type within 'typeRef'. May be + * null if the annotation targets 'typeRef' as a whole. + * @param desc + * the class descriptor of the annotation class. + * @param visible + * true if the annotation is visible at runtime. + * @return a visitor to visit the annotation values, or null if + * this visitor is not interested in visiting this annotation. + */ + public AnnotationVisitor visitTypeAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + if (api < Opcodes.ASM5) { + throw new RuntimeException(); + } + if (mv != null) { + return mv.visitTypeAnnotation(typeRef, typePath, desc, visible); + } + return null; + } + /** * Visits an annotation of a parameter this method. * @@ -201,9 +262,11 @@ public void visitCode() { *
  • {@link Opcodes#F_CHOP} representing frame with current locals are the * same as the locals in the previous frame, except that the last 1-3 locals * are absent and with the empty stack (nLocals is 1, 2 or 3).
    • - *
  • {@link Opcodes#F_FULL} representing complete frame data.
    • + *
  • {@link Opcodes#F_FULL} representing complete frame data.
    • + * + * * - *
    + *
    * In both cases the first frame, corresponding to the method's parameters * and access flags, is implicit and must not be visited. Also, it is * illegal to visit two or more frames for the same code location (i.e., at @@ -376,13 +439,52 @@ public void visitFieldInsn(int opcode, String owner, String name, * @param desc * the method's descriptor (see {@link Type Type}). */ + @Deprecated public void visitMethodInsn(int opcode, String owner, String name, String desc) { + if (api >= Opcodes.ASM5) { + boolean itf = opcode == Opcodes.INVOKEINTERFACE; + visitMethodInsn(opcode, owner, name, desc, itf); + return; + } if (mv != null) { mv.visitMethodInsn(opcode, owner, name, desc); } } + /** + * Visits a method instruction. A method instruction is an instruction that + * invokes a method. + * + * @param opcode + * the opcode of the type instruction to be visited. This opcode + * is either INVOKEVIRTUAL, INVOKESPECIAL, INVOKESTATIC or + * INVOKEINTERFACE. + * @param owner + * the internal name of the method's owner class (see + * {@link Type#getInternalName() getInternalName}). + * @param name + * the method's name. + * @param desc + * the method's descriptor (see {@link Type Type}). + * @param itf + * if the method's owner class is an interface. + */ + public void visitMethodInsn(int opcode, String owner, String name, + String desc, boolean itf) { + if (api < Opcodes.ASM5) { + if (itf != (opcode == Opcodes.INVOKEINTERFACE)) { + throw new IllegalArgumentException( + "INVOKESPECIAL/STATIC on interfaces require ASM 5"); + } + visitMethodInsn(opcode, owner, name, desc); + return; + } + if (mv != null) { + mv.visitMethodInsn(opcode, owner, name, desc, itf); + } + } + /** * Visits an invokedynamic instruction. * @@ -558,6 +660,48 @@ public void visitMultiANewArrayInsn(String desc, int dims) { } } + /** + * Visits an annotation on an instruction. This method must be called just + * after the annotated instruction. It can be called several times + * for the same instruction. + * + * @param typeRef + * a reference to the annotated type. The sort of this type + * reference must be {@link TypeReference#INSTANCEOF INSTANCEOF}, + * {@link TypeReference#NEW NEW}, + * {@link TypeReference#CONSTRUCTOR_REFERENCE + * CONSTRUCTOR_REFERENCE}, {@link TypeReference#METHOD_REFERENCE + * METHOD_REFERENCE}, {@link TypeReference#CAST CAST}, + * {@link TypeReference#CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT + * CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT}, + * {@link TypeReference#METHOD_INVOCATION_TYPE_ARGUMENT + * METHOD_INVOCATION_TYPE_ARGUMENT}, + * {@link TypeReference#CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT + * CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT}, or + * {@link TypeReference#METHOD_REFERENCE_TYPE_ARGUMENT + * METHOD_REFERENCE_TYPE_ARGUMENT}. See {@link TypeReference}. + * @param typePath + * the path to the annotated type argument, wildcard bound, array + * element type, or static inner type within 'typeRef'. May be + * null if the annotation targets 'typeRef' as a whole. + * @param desc + * the class descriptor of the annotation class. + * @param visible + * true if the annotation is visible at runtime. + * @return a visitor to visit the annotation values, or null if + * this visitor is not interested in visiting this annotation. + */ + public AnnotationVisitor visitInsnAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + if (api < Opcodes.ASM5) { + throw new RuntimeException(); + } + if (mv != null) { + return mv.visitInsnAnnotation(typeRef, typePath, desc, visible); + } + return null; + } + // ------------------------------------------------------------------------- // Exceptions table entries, debug information, max stack and max locals // ------------------------------------------------------------------------- @@ -586,6 +730,38 @@ public void visitTryCatchBlock(Label start, Label end, Label handler, } } + /** + * Visits an annotation on an exception handler type. This method must be + * called after the {@link #visitTryCatchBlock} for the annotated + * exception handler. It can be called several times for the same exception + * handler. + * + * @param typeRef + * a reference to the annotated type. The sort of this type + * reference must be {@link TypeReference#EXCEPTION_PARAMETER + * EXCEPTION_PARAMETER}. See {@link TypeReference}. + * @param typePath + * the path to the annotated type argument, wildcard bound, array + * element type, or static inner type within 'typeRef'. May be + * null if the annotation targets 'typeRef' as a whole. + * @param desc + * the class descriptor of the annotation class. + * @param visible + * true if the annotation is visible at runtime. + * @return a visitor to visit the annotation values, or null if + * this visitor is not interested in visiting this annotation. + */ + public AnnotationVisitor visitTryCatchAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + if (api < Opcodes.ASM5) { + throw new RuntimeException(); + } + if (mv != null) { + return mv.visitTryCatchAnnotation(typeRef, typePath, desc, visible); + } + return null; + } + /** * Visits a local variable declaration. * @@ -616,6 +792,48 @@ public void visitLocalVariable(String name, String desc, String signature, } } + /** + * Visits an annotation on a local variable type. + * + * @param typeRef + * a reference to the annotated type. The sort of this type + * reference must be {@link TypeReference#LOCAL_VARIABLE + * LOCAL_VARIABLE} or {@link TypeReference#RESOURCE_VARIABLE + * RESOURCE_VARIABLE}. See {@link TypeReference}. + * @param typePath + * the path to the annotated type argument, wildcard bound, array + * element type, or static inner type within 'typeRef'. May be + * null if the annotation targets 'typeRef' as a whole. + * @param start + * the fist instructions corresponding to the continuous ranges + * that make the scope of this local variable (inclusive). + * @param end + * the last instructions corresponding to the continuous ranges + * that make the scope of this local variable (exclusive). This + * array must have the same size as the 'start' array. + * @param index + * the local variable's index in each range. This array must have + * the same size as the 'start' array. + * @param desc + * the class descriptor of the annotation class. + * @param visible + * true if the annotation is visible at runtime. + * @return a visitor to visit the annotation values, or null if + * this visitor is not interested in visiting this annotation. + */ + public AnnotationVisitor visitLocalVariableAnnotation(int typeRef, + TypePath typePath, Label[] start, Label[] end, int[] index, + String desc, boolean visible) { + if (api < Opcodes.ASM5) { + throw new RuntimeException(); + } + if (mv != null) { + return mv.visitLocalVariableAnnotation(typeRef, typePath, start, + end, index, desc, visible); + } + return null; + } + /** * Visits a line number declaration. * diff --git a/src/asm/scala/tools/asm/MethodWriter.java b/src/asm/scala/tools/asm/MethodWriter.java index 87acab17c994..0c4130e4997d 100644 --- a/src/asm/scala/tools/asm/MethodWriter.java +++ b/src/asm/scala/tools/asm/MethodWriter.java @@ -191,6 +191,18 @@ class MethodWriter extends MethodVisitor { */ private AnnotationWriter ianns; + /** + * The runtime visible type annotations of this method. May be null + * . + */ + private AnnotationWriter tanns; + + /** + * The runtime invisible type annotations of this method. May be + * null. + */ + private AnnotationWriter itanns; + /** * The runtime visible parameter annotations of this method. May be * null. @@ -282,6 +294,16 @@ class MethodWriter extends MethodVisitor { */ private Handler lastHandler; + /** + * Number of entries in the MethodParameters attribute. + */ + private int methodParametersCount; + + /** + * The MethodParameters attribute. + */ + private ByteVector methodParameters; + /** * Number of entries in the LocalVariableTable attribute. */ @@ -312,6 +334,21 @@ class MethodWriter extends MethodVisitor { */ private ByteVector lineNumber; + /** + * The start offset of the last visited instruction. + */ + private int lastCodeOffset; + + /** + * The runtime visible type annotations of the code. May be null. + */ + private AnnotationWriter ctanns; + + /** + * The runtime invisible type annotations of the code. May be null. + */ + private AnnotationWriter ictanns; + /** * The non standard attributes of the method's code. */ @@ -416,7 +453,7 @@ class MethodWriter extends MethodVisitor { final String desc, final String signature, final String[] exceptions, final boolean computeMaxs, final boolean computeFrames) { - super(Opcodes.ASM4); + super(Opcodes.ASM5); if (cw.firstMethod == null) { cw.firstMethod = this; } else { @@ -461,6 +498,16 @@ class MethodWriter extends MethodVisitor { // Implementation of the MethodVisitor abstract class // ------------------------------------------------------------------------ + @Override + public void visitParameter(String name, int access) { + if (methodParameters == null) { + methodParameters = new ByteVector(); + } + ++methodParametersCount; + methodParameters.putShort((name == null) ? 0 : cw.newUTF8(name)) + .putShort(access); + } + @Override public AnnotationVisitor visitAnnotationDefault() { if (!ClassReader.ANNOTATIONS) { @@ -490,6 +537,29 @@ public AnnotationVisitor visitAnnotation(final String desc, return aw; } + @Override + public AnnotationVisitor visitTypeAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + if (!ClassReader.ANNOTATIONS) { + return null; + } + ByteVector bv = new ByteVector(); + // write target_type and target_info + AnnotationWriter.putTarget(typeRef, typePath, bv); + // write type, and reserve space for values count + bv.putShort(cw.newUTF8(desc)).putShort(0); + AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, + bv.length - 2); + if (visible) { + aw.next = tanns; + tanns = aw; + } else { + aw.next = itanns; + itanns = aw; + } + return aw; + } + @Override public AnnotationVisitor visitParameterAnnotation(final int parameter, final String desc, final boolean visible) { @@ -642,6 +712,7 @@ public void visitFrame(final int type, final int nLocal, @Override public void visitInsn(final int opcode) { + lastCodeOffset = code.length; // adds the instruction to the bytecode of the method code.putByte(opcode); // update currentBlock @@ -667,6 +738,7 @@ public void visitInsn(final int opcode) { @Override public void visitIntInsn(final int opcode, final int operand) { + lastCodeOffset = code.length; // Label currentBlock = this.currentBlock; if (currentBlock != null) { if (compute == FRAMES) { @@ -691,6 +763,7 @@ public void visitIntInsn(final int opcode, final int operand) { @Override public void visitVarInsn(final int opcode, final int var) { + lastCodeOffset = code.length; // Label currentBlock = this.currentBlock; if (currentBlock != null) { if (compute == FRAMES) { @@ -749,6 +822,7 @@ public void visitVarInsn(final int opcode, final int var) { @Override public void visitTypeInsn(final int opcode, final String type) { + lastCodeOffset = code.length; Item i = cw.newClassItem(type); // Label currentBlock = this.currentBlock; if (currentBlock != null) { @@ -771,6 +845,7 @@ public void visitTypeInsn(final int opcode, final String type) { @Override public void visitFieldInsn(final int opcode, final String owner, final String name, final String desc) { + lastCodeOffset = code.length; Item i = cw.newFieldItem(owner, name, desc); // Label currentBlock = this.currentBlock; if (currentBlock != null) { @@ -808,8 +883,8 @@ public void visitFieldInsn(final int opcode, final String owner, @Override public void visitMethodInsn(final int opcode, final String owner, - final String name, final String desc) { - boolean itf = opcode == Opcodes.INVOKEINTERFACE; + final String name, final String desc, final boolean itf) { + lastCodeOffset = code.length; Item i = cw.newMethodItem(owner, name, desc, itf); int argSize = i.intVal; // Label currentBlock = this.currentBlock; @@ -847,7 +922,7 @@ public void visitMethodInsn(final int opcode, final String owner, } } // adds the instruction to the bytecode of the method - if (itf) { + if (opcode == Opcodes.INVOKEINTERFACE) { if (argSize == 0) { argSize = Type.getArgumentsAndReturnSizes(desc); i.intVal = argSize; @@ -861,6 +936,7 @@ public void visitMethodInsn(final int opcode, final String owner, @Override public void visitInvokeDynamicInsn(final String name, final String desc, final Handle bsm, final Object... bsmArgs) { + lastCodeOffset = code.length; Item i = cw.newInvokeDynamicItem(name, desc, bsm, bsmArgs); int argSize = i.intVal; // Label currentBlock = this.currentBlock; @@ -900,6 +976,7 @@ public void visitInvokeDynamicInsn(final String name, final String desc, @Override public void visitJumpInsn(final int opcode, final Label label) { + lastCodeOffset = code.length; Label nextInsn = null; // Label currentBlock = this.currentBlock; if (currentBlock != null) { @@ -1045,6 +1122,7 @@ public void visitLabel(final Label label) { @Override public void visitLdcInsn(final Object cst) { + lastCodeOffset = code.length; Item i = cw.newConstItem(cst); // Label currentBlock = this.currentBlock; if (currentBlock != null) { @@ -1078,6 +1156,7 @@ public void visitLdcInsn(final Object cst) { @Override public void visitIincInsn(final int var, final int increment) { + lastCodeOffset = code.length; if (currentBlock != null) { if (compute == FRAMES) { currentBlock.frame.execute(Opcodes.IINC, var, null, null); @@ -1102,6 +1181,7 @@ public void visitIincInsn(final int var, final int increment) { @Override public void visitTableSwitchInsn(final int min, final int max, final Label dflt, final Label... labels) { + lastCodeOffset = code.length; // adds the instruction to the bytecode of the method int source = code.length; code.putByte(Opcodes.TABLESWITCH); @@ -1118,6 +1198,7 @@ public void visitTableSwitchInsn(final int min, final int max, @Override public void visitLookupSwitchInsn(final Label dflt, final int[] keys, final Label[] labels) { + lastCodeOffset = code.length; // adds the instruction to the bytecode of the method int source = code.length; code.putByte(Opcodes.LOOKUPSWITCH); @@ -1160,6 +1241,7 @@ private void visitSwitchInsn(final Label dflt, final Label[] labels) { @Override public void visitMultiANewArrayInsn(final String desc, final int dims) { + lastCodeOffset = code.length; Item i = cw.newClassItem(desc); // Label currentBlock = this.currentBlock; if (currentBlock != null) { @@ -1175,6 +1257,30 @@ public void visitMultiANewArrayInsn(final String desc, final int dims) { code.put12(Opcodes.MULTIANEWARRAY, i.index).putByte(dims); } + @Override + public AnnotationVisitor visitInsnAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + if (!ClassReader.ANNOTATIONS) { + return null; + } + ByteVector bv = new ByteVector(); + // write target_type and target_info + typeRef = (typeRef & 0xFF0000FF) | (lastCodeOffset << 8); + AnnotationWriter.putTarget(typeRef, typePath, bv); + // write type, and reserve space for values count + bv.putShort(cw.newUTF8(desc)).putShort(0); + AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, + bv.length - 2); + if (visible) { + aw.next = ctanns; + ctanns = aw; + } else { + aw.next = ictanns; + ictanns = aw; + } + return aw; + } + @Override public void visitTryCatchBlock(final Label start, final Label end, final Label handler, final String type) { @@ -1193,6 +1299,29 @@ public void visitTryCatchBlock(final Label start, final Label end, lastHandler = h; } + @Override + public AnnotationVisitor visitTryCatchAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + if (!ClassReader.ANNOTATIONS) { + return null; + } + ByteVector bv = new ByteVector(); + // write target_type and target_info + AnnotationWriter.putTarget(typeRef, typePath, bv); + // write type, and reserve space for values count + bv.putShort(cw.newUTF8(desc)).putShort(0); + AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, + bv.length - 2); + if (visible) { + aw.next = ctanns; + ctanns = aw; + } else { + aw.next = ictanns; + ictanns = aw; + } + return aw; + } + @Override public void visitLocalVariable(final String name, final String desc, final String signature, final Label start, final Label end, @@ -1225,6 +1354,41 @@ public void visitLocalVariable(final String name, final String desc, } } + @Override + public AnnotationVisitor visitLocalVariableAnnotation(int typeRef, + TypePath typePath, Label[] start, Label[] end, int[] index, + String desc, boolean visible) { + if (!ClassReader.ANNOTATIONS) { + return null; + } + ByteVector bv = new ByteVector(); + // write target_type and target_info + bv.putByte(typeRef >>> 24).putShort(start.length); + for (int i = 0; i < start.length; ++i) { + bv.putShort(start[i].position) + .putShort(end[i].position - start[i].position) + .putShort(index[i]); + } + if (typePath == null) { + bv.putByte(0); + } else { + int length = typePath.b[typePath.offset] * 2 + 1; + bv.putByteArray(typePath.b, typePath.offset, length); + } + // write type, and reserve space for values count + bv.putShort(cw.newUTF8(desc)).putShort(0); + AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, + bv.length - 2); + if (visible) { + aw.next = ctanns; + ctanns = aw; + } else { + aw.next = ictanns; + ictanns = aw; + } + return aw; + } + @Override public void visitLineNumber(final int line, final Label start) { if (lineNumber == null) { @@ -1237,6 +1401,14 @@ public void visitLineNumber(final int line, final Label start) { @Override public void visitMaxs(final int maxStack, final int maxLocals) { + if (resize) { + // replaces the temporary jump opcodes introduced by Label.resolve. + if (ClassReader.RESIZE) { + resizeInstructions(); + } else { + throw new RuntimeException("Method code too large!"); + } + } if (ClassReader.FRAMES && compute == FRAMES) { // completes the control flow graph with exception handler blocks Handler handler = firstHandler; @@ -1858,22 +2030,12 @@ final int getSize() { if (classReaderOffset != 0) { return 6 + classReaderLength; } - if (resize) { - // replaces the temporary jump opcodes introduced by Label.resolve. - if (ClassReader.RESIZE) { - resizeInstructions(); - } else { - throw new RuntimeException("Method code too large!"); - } - } int size = 8; if (code.length > 0) { if (code.length > 65536) { String nameString = ""; - int i = 0; - // find item that corresponds to the index of our name - while (i < cw.items.length && (cw.items[i] == null || cw.items[i].index != name)) i++; - if (cw.items[i] != null) nameString = cw.items[i].strVal1 +"'s "; + Item nameItem = cw.findItemByIndex(name); + if (nameItem != null) nameString = nameItem.strVal1 +"'s "; throw new RuntimeException("Method "+ nameString +"code too large!"); } cw.newUTF8("Code"); @@ -1895,6 +2057,14 @@ final int getSize() { cw.newUTF8(zip ? "StackMapTable" : "StackMap"); size += 8 + stackMap.length; } + if (ClassReader.ANNOTATIONS && ctanns != null) { + cw.newUTF8("RuntimeVisibleTypeAnnotations"); + size += 8 + ctanns.getSize(); + } + if (ClassReader.ANNOTATIONS && ictanns != null) { + cw.newUTF8("RuntimeInvisibleTypeAnnotations"); + size += 8 + ictanns.getSize(); + } if (cattrs != null) { size += cattrs.getSize(cw, code.data, code.length, maxStack, maxLocals); @@ -1920,6 +2090,10 @@ final int getSize() { cw.newUTF8(signature); size += 8; } + if (methodParameters != null) { + cw.newUTF8("MethodParameters"); + size += 7 + methodParameters.length; + } if (ClassReader.ANNOTATIONS && annd != null) { cw.newUTF8("AnnotationDefault"); size += 6 + annd.length; @@ -1932,6 +2106,14 @@ final int getSize() { cw.newUTF8("RuntimeInvisibleAnnotations"); size += 8 + ianns.getSize(); } + if (ClassReader.ANNOTATIONS && tanns != null) { + cw.newUTF8("RuntimeVisibleTypeAnnotations"); + size += 8 + tanns.getSize(); + } + if (ClassReader.ANNOTATIONS && itanns != null) { + cw.newUTF8("RuntimeInvisibleTypeAnnotations"); + size += 8 + itanns.getSize(); + } if (ClassReader.ANNOTATIONS && panns != null) { cw.newUTF8("RuntimeVisibleParameterAnnotations"); size += 7 + 2 * (panns.length - synthetics); @@ -1988,6 +2170,9 @@ final void put(final ByteVector out) { if (ClassReader.SIGNATURES && signature != null) { ++attributeCount; } + if (methodParameters != null) { + ++attributeCount; + } if (ClassReader.ANNOTATIONS && annd != null) { ++attributeCount; } @@ -1997,6 +2182,12 @@ final void put(final ByteVector out) { if (ClassReader.ANNOTATIONS && ianns != null) { ++attributeCount; } + if (ClassReader.ANNOTATIONS && tanns != null) { + ++attributeCount; + } + if (ClassReader.ANNOTATIONS && itanns != null) { + ++attributeCount; + } if (ClassReader.ANNOTATIONS && panns != null) { ++attributeCount; } @@ -2021,6 +2212,12 @@ final void put(final ByteVector out) { if (stackMap != null) { size += 8 + stackMap.length; } + if (ClassReader.ANNOTATIONS && ctanns != null) { + size += 8 + ctanns.getSize(); + } + if (ClassReader.ANNOTATIONS && ictanns != null) { + size += 8 + ictanns.getSize(); + } if (cattrs != null) { size += cattrs.getSize(cw, code.data, code.length, maxStack, maxLocals); @@ -2050,6 +2247,12 @@ final void put(final ByteVector out) { if (stackMap != null) { ++attributeCount; } + if (ClassReader.ANNOTATIONS && ctanns != null) { + ++attributeCount; + } + if (ClassReader.ANNOTATIONS && ictanns != null) { + ++attributeCount; + } if (cattrs != null) { attributeCount += cattrs.getCount(); } @@ -2075,6 +2278,14 @@ final void put(final ByteVector out) { out.putInt(stackMap.length + 2).putShort(frameCount); out.putByteArray(stackMap.data, 0, stackMap.length); } + if (ClassReader.ANNOTATIONS && ctanns != null) { + out.putShort(cw.newUTF8("RuntimeVisibleTypeAnnotations")); + ctanns.put(out); + } + if (ClassReader.ANNOTATIONS && ictanns != null) { + out.putShort(cw.newUTF8("RuntimeInvisibleTypeAnnotations")); + ictanns.put(out); + } if (cattrs != null) { cattrs.put(cw, code.data, code.length, maxLocals, maxStack, out); } @@ -2100,6 +2311,12 @@ final void put(final ByteVector out) { out.putShort(cw.newUTF8("Signature")).putInt(2) .putShort(cw.newUTF8(signature)); } + if (methodParameters != null) { + out.putShort(cw.newUTF8("MethodParameters")); + out.putInt(methodParameters.length + 1).putByte( + methodParametersCount); + out.putByteArray(methodParameters.data, 0, methodParameters.length); + } if (ClassReader.ANNOTATIONS && annd != null) { out.putShort(cw.newUTF8("AnnotationDefault")); out.putInt(annd.length); @@ -2113,6 +2330,14 @@ final void put(final ByteVector out) { out.putShort(cw.newUTF8("RuntimeInvisibleAnnotations")); ianns.put(out); } + if (ClassReader.ANNOTATIONS && tanns != null) { + out.putShort(cw.newUTF8("RuntimeVisibleTypeAnnotations")); + tanns.put(out); + } + if (ClassReader.ANNOTATIONS && itanns != null) { + out.putShort(cw.newUTF8("RuntimeInvisibleTypeAnnotations")); + itanns.put(out); + } if (ClassReader.ANNOTATIONS && panns != null) { out.putShort(cw.newUTF8("RuntimeVisibleParameterAnnotations")); AnnotationWriter.put(panns, synthetics, out); @@ -2464,49 +2689,50 @@ private void resizeInstructions() { } } - // recomputes the stack map frames - if (frameCount > 0) { - if (compute == FRAMES) { - frameCount = 0; - stackMap = null; - previousFrame = null; - frame = null; - Frame f = new Frame(); - f.owner = labels; - Type[] args = Type.getArgumentTypes(descriptor); - f.initInputFrame(cw, access, args, maxLocals); - visitFrame(f); - Label l = labels; - while (l != null) { - /* - * here we need the original label position. getNewOffset - * must therefore never have been called for this label. - */ - u = l.position - 3; - if ((l.status & Label.STORE) != 0 || (u >= 0 && resize[u])) { - getNewOffset(allIndexes, allSizes, l); - // TODO update offsets in UNINITIALIZED values - visitFrame(l.frame); - } - l = l.successor; - } - } else { + // updates the stack map frame labels + if (compute == FRAMES) { + Label l = labels; + while (l != null) { /* - * Resizing an existing stack map frame table is really hard. - * Not only the table must be parsed to update the offets, but - * new frames may be needed for jump instructions that were - * inserted by this method. And updating the offsets or - * inserting frames can change the format of the following - * frames, in case of packed frames. In practice the whole table - * must be recomputed. For this the frames are marked as - * potentially invalid. This will cause the whole class to be - * reread and rewritten with the COMPUTE_FRAMES option (see the - * ClassWriter.toByteArray method). This is not very efficient - * but is much easier and requires much less code than any other - * method I can think of. + * Detects the labels that are just after an IF instruction that + * has been resized with the IFNOT GOTO_W pattern. These labels + * are now the target of a jump instruction (the IFNOT + * instruction). Note that we need the original label position + * here. getNewOffset must therefore never have been called for + * this label. */ - cw.invalidFrames = true; + u = l.position - 3; + if (u >= 0 && resize[u]) { + l.status |= Label.TARGET; + } + getNewOffset(allIndexes, allSizes, l); + l = l.successor; } + // Update the offsets in the uninitialized types + for (i = 0; i < cw.typeTable.length; ++i) { + Item item = cw.typeTable[i]; + if (item != null && item.type == ClassWriter.TYPE_UNINIT) { + item.intVal = getNewOffset(allIndexes, allSizes, 0, + item.intVal); + } + } + // The stack map frames are not serialized yet, so we don't need + // to update them. They will be serialized in visitMaxs. + } else if (frameCount > 0) { + /* + * Resizing an existing stack map frame table is really hard. Not + * only the table must be parsed to update the offets, but new + * frames may be needed for jump instructions that were inserted by + * this method. And updating the offsets or inserting frames can + * change the format of the following frames, in case of packed + * frames. In practice the whole table must be recomputed. For this + * the frames are marked as potentially invalid. This will cause the + * whole class to be reread and rewritten with the COMPUTE_FRAMES + * option (see the ClassWriter.toByteArray method). This is not very + * efficient but is much easier and requires much less code than any + * other method I can think of. + */ + cw.invalidFrames = true; } // updates the exception handler block labels Handler h = firstHandler; diff --git a/src/asm/scala/tools/asm/Opcodes.java b/src/asm/scala/tools/asm/Opcodes.java index 809e5ae5908e..24eaffa71794 100644 --- a/src/asm/scala/tools/asm/Opcodes.java +++ b/src/asm/scala/tools/asm/Opcodes.java @@ -46,6 +46,7 @@ public interface Opcodes { // ASM API versions int ASM4 = 4 << 16 | 0 << 8 | 0; + int ASM5 = 5 << 16 | 0 << 8 | 0; // versions @@ -56,6 +57,7 @@ public interface Opcodes { int V1_5 = 0 << 16 | 49; int V1_6 = 0 << 16 | 50; int V1_7 = 0 << 16 | 51; + int V1_8 = 0 << 16 | 52; // access flags @@ -63,7 +65,7 @@ public interface Opcodes { int ACC_PRIVATE = 0x0002; // class, field, method int ACC_PROTECTED = 0x0004; // class, field, method int ACC_STATIC = 0x0008; // field, method - int ACC_FINAL = 0x0010; // class, field, method + int ACC_FINAL = 0x0010; // class, field, method, parameter int ACC_SUPER = 0x0020; // class int ACC_SYNCHRONIZED = 0x0020; // method int ACC_VOLATILE = 0x0040; // field @@ -74,9 +76,10 @@ public interface Opcodes { int ACC_INTERFACE = 0x0200; // class int ACC_ABSTRACT = 0x0400; // class, method int ACC_STRICT = 0x0800; // method - int ACC_SYNTHETIC = 0x1000; // class, field, method + int ACC_SYNTHETIC = 0x1000; // class, field, method, parameter int ACC_ANNOTATION = 0x2000; // class int ACC_ENUM = 0x4000; // class(?) field inner + int ACC_MANDATED = 0x8000; // parameter // ASM specific pseudo access flags diff --git a/src/asm/scala/tools/asm/Type.java b/src/asm/scala/tools/asm/Type.java index 7821a492e661..7887080dee89 100644 --- a/src/asm/scala/tools/asm/Type.java +++ b/src/asm/scala/tools/asm/Type.java @@ -401,8 +401,8 @@ public static Type getReturnType(final Method method) { * @return the size of the arguments of the method (plus one for the * implicit this argument), argSize, and the size of its return * value, retSize, packed into a single int i = - * (argSize << 2) | retSize (argSize is therefore equal to - * i >> 2, and retSize to i & 0x03). + * (argSize << 2) | retSize (argSize is therefore equal to + * i >> 2, and retSize to i & 0x03). */ public static int getArgumentsAndReturnSizes(final String desc) { int n = 1; @@ -606,9 +606,10 @@ public Type getReturnType() { * * @return the size of the arguments (plus one for the implicit this * argument), argSize, and the size of the return value, retSize, - * packed into a single int i = (argSize << 2) | retSize - * (argSize is therefore equal to i >> 2, and retSize to - * i & 0x03). + * packed into a single + * int i = (argSize << 2) | retSize + * (argSize is therefore equal to i >> 2, + * and retSize to i & 0x03). */ public int getArgumentsAndReturnSizes() { return getArgumentsAndReturnSizes(getDescriptor()); diff --git a/src/asm/scala/tools/asm/TypePath.java b/src/asm/scala/tools/asm/TypePath.java new file mode 100644 index 000000000000..d4c6f0d8570c --- /dev/null +++ b/src/asm/scala/tools/asm/TypePath.java @@ -0,0 +1,193 @@ +/*** + * ASM: a very small and fast Java bytecode manipulation framework + * Copyright (c) 2000-2013 INRIA, France Telecom + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +package scala.tools.asm; + +/** + * The path to a type argument, wildcard bound, array element type, or static + * inner type within an enclosing type. + * + * @author Eric Bruneton + */ +public class TypePath { + + /** + * A type path step that steps into the element type of an array type. See + * {@link #getStep getStep}. + */ + public final static int ARRAY_ELEMENT = 0; + + /** + * A type path step that steps into the nested type of a class type. See + * {@link #getStep getStep}. + */ + public final static int INNER_TYPE = 1; + + /** + * A type path step that steps into the bound of a wildcard type. See + * {@link #getStep getStep}. + */ + public final static int WILDCARD_BOUND = 2; + + /** + * A type path step that steps into a type argument of a generic type. See + * {@link #getStep getStep}. + */ + public final static int TYPE_ARGUMENT = 3; + + /** + * The byte array where the path is stored, in Java class file format. + */ + byte[] b; + + /** + * The offset of the first byte of the type path in 'b'. + */ + int offset; + + /** + * Creates a new type path. + * + * @param b + * the byte array containing the type path in Java class file + * format. + * @param offset + * the offset of the first byte of the type path in 'b'. + */ + TypePath(byte[] b, int offset) { + this.b = b; + this.offset = offset; + } + + /** + * Returns the length of this path. + * + * @return the length of this path. + */ + public int getLength() { + return b[offset]; + } + + /** + * Returns the value of the given step of this path. + * + * @param index + * an index between 0 and {@link #getLength()}, exclusive. + * @return {@link #ARRAY_ELEMENT ARRAY_ELEMENT}, {@link #INNER_TYPE + * INNER_TYPE}, {@link #WILDCARD_BOUND WILDCARD_BOUND}, or + * {@link #TYPE_ARGUMENT TYPE_ARGUMENT}. + */ + public int getStep(int index) { + return b[offset + 2 * index + 1]; + } + + /** + * Returns the index of the type argument that the given step is stepping + * into. This method should only be used for steps whose value is + * {@link #TYPE_ARGUMENT TYPE_ARGUMENT}. + * + * @param index + * an index between 0 and {@link #getLength()}, exclusive. + * @return the index of the type argument that the given step is stepping + * into. + */ + public int getStepArgument(int index) { + return b[offset + 2 * index + 2]; + } + + /** + * Converts a type path in string form, in the format used by + * {@link #toString()}, into a TypePath object. + * + * @param typePath + * a type path in string form, in the format used by + * {@link #toString()}. May be null or empty. + * @return the corresponding TypePath object, or null if the path is empty. + */ + public static TypePath fromString(final String typePath) { + if (typePath == null || typePath.length() == 0) { + return null; + } + int n = typePath.length(); + ByteVector out = new ByteVector(n); + out.putByte(0); + for (int i = 0; i < n;) { + char c = typePath.charAt(i++); + if (c == '[') { + out.put11(ARRAY_ELEMENT, 0); + } else if (c == '.') { + out.put11(INNER_TYPE, 0); + } else if (c == '*') { + out.put11(WILDCARD_BOUND, 0); + } else if (c >= '0' && c <= '9') { + int typeArg = c - '0'; + while (i < n && (c = typePath.charAt(i)) >= '0' && c <= '9') { + typeArg = typeArg * 10 + c - '0'; + i += 1; + } + out.put11(TYPE_ARGUMENT, typeArg); + } + } + out.data[0] = (byte) (out.length / 2); + return new TypePath(out.data, 0); + } + + /** + * Returns a string representation of this type path. {@link #ARRAY_ELEMENT + * ARRAY_ELEMENT} steps are represented with '[', {@link #INNER_TYPE + * INNER_TYPE} steps with '.', {@link #WILDCARD_BOUND WILDCARD_BOUND} steps + * with '*' and {@link #TYPE_ARGUMENT TYPE_ARGUMENT} steps with their type + * argument index in decimal form. + */ + @Override + public String toString() { + int length = getLength(); + StringBuilder result = new StringBuilder(length * 2); + for (int i = 0; i < length; ++i) { + switch (getStep(i)) { + case ARRAY_ELEMENT: + result.append('['); + break; + case INNER_TYPE: + result.append('.'); + break; + case WILDCARD_BOUND: + result.append('*'); + break; + case TYPE_ARGUMENT: + result.append(getStepArgument(i)); + break; + default: + result.append('_'); + } + } + return result.toString(); + } +} diff --git a/src/asm/scala/tools/asm/TypeReference.java b/src/asm/scala/tools/asm/TypeReference.java new file mode 100644 index 000000000000..118b0f6529f9 --- /dev/null +++ b/src/asm/scala/tools/asm/TypeReference.java @@ -0,0 +1,452 @@ +/*** + * ASM: a very small and fast Java bytecode manipulation framework + * Copyright (c) 2000-2013 INRIA, France Telecom + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +package scala.tools.asm; + +/** + * A reference to a type appearing in a class, field or method declaration, or + * on an instruction. Such a reference designates the part of the class where + * the referenced type is appearing (e.g. an 'extends', 'implements' or 'throws' + * clause, a 'new' instruction, a 'catch' clause, a type cast, a local variable + * declaration, etc). + * + * @author Eric Bruneton + */ +public class TypeReference { + + /** + * The sort of type references that target a type parameter of a generic + * class. See {@link #getSort getSort}. + */ + public final static int CLASS_TYPE_PARAMETER = 0x00; + + /** + * The sort of type references that target a type parameter of a generic + * method. See {@link #getSort getSort}. + */ + public final static int METHOD_TYPE_PARAMETER = 0x01; + + /** + * The sort of type references that target the super class of a class or one + * of the interfaces it implements. See {@link #getSort getSort}. + */ + public final static int CLASS_EXTENDS = 0x10; + + /** + * The sort of type references that target a bound of a type parameter of a + * generic class. See {@link #getSort getSort}. + */ + public final static int CLASS_TYPE_PARAMETER_BOUND = 0x11; + + /** + * The sort of type references that target a bound of a type parameter of a + * generic method. See {@link #getSort getSort}. + */ + public final static int METHOD_TYPE_PARAMETER_BOUND = 0x12; + + /** + * The sort of type references that target the type of a field. See + * {@link #getSort getSort}. + */ + public final static int FIELD = 0x13; + + /** + * The sort of type references that target the return type of a method. See + * {@link #getSort getSort}. + */ + public final static int METHOD_RETURN = 0x14; + + /** + * The sort of type references that target the receiver type of a method. + * See {@link #getSort getSort}. + */ + public final static int METHOD_RECEIVER = 0x15; + + /** + * The sort of type references that target the type of a formal parameter of + * a method. See {@link #getSort getSort}. + */ + public final static int METHOD_FORMAL_PARAMETER = 0x16; + + /** + * The sort of type references that target the type of an exception declared + * in the throws clause of a method. See {@link #getSort getSort}. + */ + public final static int THROWS = 0x17; + + /** + * The sort of type references that target the type of a local variable in a + * method. See {@link #getSort getSort}. + */ + public final static int LOCAL_VARIABLE = 0x40; + + /** + * The sort of type references that target the type of a resource variable + * in a method. See {@link #getSort getSort}. + */ + public final static int RESOURCE_VARIABLE = 0x41; + + /** + * The sort of type references that target the type of the exception of a + * 'catch' clause in a method. See {@link #getSort getSort}. + */ + public final static int EXCEPTION_PARAMETER = 0x42; + + /** + * The sort of type references that target the type declared in an + * 'instanceof' instruction. See {@link #getSort getSort}. + */ + public final static int INSTANCEOF = 0x43; + + /** + * The sort of type references that target the type of the object created by + * a 'new' instruction. See {@link #getSort getSort}. + */ + public final static int NEW = 0x44; + + /** + * The sort of type references that target the receiver type of a + * constructor reference. See {@link #getSort getSort}. + */ + public final static int CONSTRUCTOR_REFERENCE = 0x45; + + /** + * The sort of type references that target the receiver type of a method + * reference. See {@link #getSort getSort}. + */ + public final static int METHOD_REFERENCE = 0x46; + + /** + * The sort of type references that target the type declared in an explicit + * or implicit cast instruction. See {@link #getSort getSort}. + */ + public final static int CAST = 0x47; + + /** + * The sort of type references that target a type parameter of a generic + * constructor in a constructor call. See {@link #getSort getSort}. + */ + public final static int CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT = 0x48; + + /** + * The sort of type references that target a type parameter of a generic + * method in a method call. See {@link #getSort getSort}. + */ + public final static int METHOD_INVOCATION_TYPE_ARGUMENT = 0x49; + + /** + * The sort of type references that target a type parameter of a generic + * constructor in a constructor reference. See {@link #getSort getSort}. + */ + public final static int CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT = 0x4A; + + /** + * The sort of type references that target a type parameter of a generic + * method in a method reference. See {@link #getSort getSort}. + */ + public final static int METHOD_REFERENCE_TYPE_ARGUMENT = 0x4B; + + /** + * The type reference value in Java class file format. + */ + private int value; + + /** + * Creates a new TypeReference. + * + * @param typeRef + * the int encoded value of the type reference, as received in a + * visit method related to type annotations, like + * visitTypeAnnotation. + */ + public TypeReference(int typeRef) { + this.value = typeRef; + } + + /** + * Returns a type reference of the given sort. + * + * @param sort + * {@link #FIELD FIELD}, {@link #METHOD_RETURN METHOD_RETURN}, + * {@link #METHOD_RECEIVER METHOD_RECEIVER}, + * {@link #LOCAL_VARIABLE LOCAL_VARIABLE}, + * {@link #RESOURCE_VARIABLE RESOURCE_VARIABLE}, + * {@link #INSTANCEOF INSTANCEOF}, {@link #NEW NEW}, + * {@link #CONSTRUCTOR_REFERENCE CONSTRUCTOR_REFERENCE}, or + * {@link #METHOD_REFERENCE METHOD_REFERENCE}. + * @return a type reference of the given sort. + */ + public static TypeReference newTypeReference(int sort) { + return new TypeReference(sort << 24); + } + + /** + * Returns a reference to a type parameter of a generic class or method. + * + * @param sort + * {@link #CLASS_TYPE_PARAMETER CLASS_TYPE_PARAMETER} or + * {@link #METHOD_TYPE_PARAMETER METHOD_TYPE_PARAMETER}. + * @param paramIndex + * the type parameter index. + * @return a reference to the given generic class or method type parameter. + */ + public static TypeReference newTypeParameterReference(int sort, + int paramIndex) { + return new TypeReference((sort << 24) | (paramIndex << 16)); + } + + /** + * Returns a reference to a type parameter bound of a generic class or + * method. + * + * @param sort + * {@link #CLASS_TYPE_PARAMETER CLASS_TYPE_PARAMETER} or + * {@link #METHOD_TYPE_PARAMETER METHOD_TYPE_PARAMETER}. + * @param paramIndex + * the type parameter index. + * @param boundIndex + * the type bound index within the above type parameters. + * @return a reference to the given generic class or method type parameter + * bound. + */ + public static TypeReference newTypeParameterBoundReference(int sort, + int paramIndex, int boundIndex) { + return new TypeReference((sort << 24) | (paramIndex << 16) + | (boundIndex << 8)); + } + + /** + * Returns a reference to the super class or to an interface of the + * 'implements' clause of a class. + * + * @param itfIndex + * the index of an interface in the 'implements' clause of a + * class, or -1 to reference the super class of the class. + * @return a reference to the given super type of a class. + */ + public static TypeReference newSuperTypeReference(int itfIndex) { + itfIndex &= 0xFFFF; + return new TypeReference((CLASS_EXTENDS << 24) | (itfIndex << 8)); + } + + /** + * Returns a reference to the type of a formal parameter of a method. + * + * @param paramIndex + * the formal parameter index. + * + * @return a reference to the type of the given method formal parameter. + */ + public static TypeReference newFormalParameterReference(int paramIndex) { + return new TypeReference((METHOD_FORMAL_PARAMETER << 24) + | (paramIndex << 16)); + } + + /** + * Returns a reference to the type of an exception, in a 'throws' clause of + * a method. + * + * @param exceptionIndex + * the index of an exception in a 'throws' clause of a method. + * + * @return a reference to the type of the given exception. + */ + public static TypeReference newExceptionReference(int exceptionIndex) { + return new TypeReference((THROWS << 24) | (exceptionIndex << 8)); + } + + /** + * Returns a reference to the type of the exception declared in a 'catch' + * clause of a method. + * + * @param tryCatchBlockIndex + * the index of a try catch block (using the order in which they + * are visited with visitTryCatchBlock). + * + * @return a reference to the type of the given exception. + */ + public static TypeReference newTryCatchReference(int tryCatchBlockIndex) { + return new TypeReference((EXCEPTION_PARAMETER << 24) + | (tryCatchBlockIndex << 8)); + } + + /** + * Returns a reference to the type of a type argument in a constructor or + * method call or reference. + * + * @param sort + * {@link #CAST CAST}, + * {@link #CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT + * CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT}, + * {@link #METHOD_INVOCATION_TYPE_ARGUMENT + * METHOD_INVOCATION_TYPE_ARGUMENT}, + * {@link #CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT + * CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT}, or + * {@link #METHOD_REFERENCE_TYPE_ARGUMENT + * METHOD_REFERENCE_TYPE_ARGUMENT}. + * @param argIndex + * the type argument index. + * + * @return a reference to the type of the given type argument. + */ + public static TypeReference newTypeArgumentReference(int sort, int argIndex) { + return new TypeReference((sort << 24) | argIndex); + } + + /** + * Returns the sort of this type reference. + * + * @return {@link #CLASS_TYPE_PARAMETER CLASS_TYPE_PARAMETER}, + * {@link #METHOD_TYPE_PARAMETER METHOD_TYPE_PARAMETER}, + * {@link #CLASS_EXTENDS CLASS_EXTENDS}, + * {@link #CLASS_TYPE_PARAMETER_BOUND CLASS_TYPE_PARAMETER_BOUND}, + * {@link #METHOD_TYPE_PARAMETER_BOUND METHOD_TYPE_PARAMETER_BOUND}, + * {@link #FIELD FIELD}, {@link #METHOD_RETURN METHOD_RETURN}, + * {@link #METHOD_RECEIVER METHOD_RECEIVER}, + * {@link #METHOD_FORMAL_PARAMETER METHOD_FORMAL_PARAMETER}, + * {@link #THROWS THROWS}, {@link #LOCAL_VARIABLE LOCAL_VARIABLE}, + * {@link #RESOURCE_VARIABLE RESOURCE_VARIABLE}, + * {@link #EXCEPTION_PARAMETER EXCEPTION_PARAMETER}, + * {@link #INSTANCEOF INSTANCEOF}, {@link #NEW NEW}, + * {@link #CONSTRUCTOR_REFERENCE CONSTRUCTOR_REFERENCE}, + * {@link #METHOD_REFERENCE METHOD_REFERENCE}, {@link #CAST CAST}, + * {@link #CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT + * CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT}, + * {@link #METHOD_INVOCATION_TYPE_ARGUMENT + * METHOD_INVOCATION_TYPE_ARGUMENT}, + * {@link #CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT + * CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT}, or + * {@link #METHOD_REFERENCE_TYPE_ARGUMENT + * METHOD_REFERENCE_TYPE_ARGUMENT}. + */ + public int getSort() { + return value >>> 24; + } + + /** + * Returns the index of the type parameter referenced by this type + * reference. This method must only be used for type references whose sort + * is {@link #CLASS_TYPE_PARAMETER CLASS_TYPE_PARAMETER}, + * {@link #METHOD_TYPE_PARAMETER METHOD_TYPE_PARAMETER}, + * {@link #CLASS_TYPE_PARAMETER_BOUND CLASS_TYPE_PARAMETER_BOUND} or + * {@link #METHOD_TYPE_PARAMETER_BOUND METHOD_TYPE_PARAMETER_BOUND}. + * + * @return a type parameter index. + */ + public int getTypeParameterIndex() { + return (value & 0x00FF0000) >> 16; + } + + /** + * Returns the index of the type parameter bound, within the type parameter + * {@link #getTypeParameterIndex}, referenced by this type reference. This + * method must only be used for type references whose sort is + * {@link #CLASS_TYPE_PARAMETER_BOUND CLASS_TYPE_PARAMETER_BOUND} or + * {@link #METHOD_TYPE_PARAMETER_BOUND METHOD_TYPE_PARAMETER_BOUND}. + * + * @return a type parameter bound index. + */ + public int getTypeParameterBoundIndex() { + return (value & 0x0000FF00) >> 8; + } + + /** + * Returns the index of the "super type" of a class that is referenced by + * this type reference. This method must only be used for type references + * whose sort is {@link #CLASS_EXTENDS CLASS_EXTENDS}. + * + * @return the index of an interface in the 'implements' clause of a class, + * or -1 if this type reference references the type of the super + * class. + */ + public int getSuperTypeIndex() { + return (short) ((value & 0x00FFFF00) >> 8); + } + + /** + * Returns the index of the formal parameter whose type is referenced by + * this type reference. This method must only be used for type references + * whose sort is {@link #METHOD_FORMAL_PARAMETER METHOD_FORMAL_PARAMETER}. + * + * @return a formal parameter index. + */ + public int getFormalParameterIndex() { + return (value & 0x00FF0000) >> 16; + } + + /** + * Returns the index of the exception, in a 'throws' clause of a method, + * whose type is referenced by this type reference. This method must only be + * used for type references whose sort is {@link #THROWS THROWS}. + * + * @return the index of an exception in the 'throws' clause of a method. + */ + public int getExceptionIndex() { + return (value & 0x00FFFF00) >> 8; + } + + /** + * Returns the index of the try catch block (using the order in which they + * are visited with visitTryCatchBlock), whose 'catch' type is referenced by + * this type reference. This method must only be used for type references + * whose sort is {@link #EXCEPTION_PARAMETER EXCEPTION_PARAMETER} . + * + * @return the index of an exception in the 'throws' clause of a method. + */ + public int getTryCatchBlockIndex() { + return (value & 0x00FFFF00) >> 8; + } + + /** + * Returns the index of the type argument referenced by this type reference. + * This method must only be used for type references whose sort is + * {@link #CAST CAST}, {@link #CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT + * CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT}, + * {@link #METHOD_INVOCATION_TYPE_ARGUMENT METHOD_INVOCATION_TYPE_ARGUMENT}, + * {@link #CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT + * CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT}, or + * {@link #METHOD_REFERENCE_TYPE_ARGUMENT METHOD_REFERENCE_TYPE_ARGUMENT}. + * + * @return a type parameter index. + */ + public int getTypeArgumentIndex() { + return value & 0xFF; + } + + /** + * Returns the int encoded value of this type reference, suitable for use in + * visit methods related to type annotations, like visitTypeAnnotation. + * + * @return the int encoded value of this type reference. + */ + public int getValue() { + return value; + } +} diff --git a/src/asm/scala/tools/asm/signature/SignatureVisitor.java b/src/asm/scala/tools/asm/signature/SignatureVisitor.java index f38f81f53b8b..1e16bd3f7c7b 100644 --- a/src/asm/scala/tools/asm/signature/SignatureVisitor.java +++ b/src/asm/scala/tools/asm/signature/SignatureVisitor.java @@ -73,7 +73,7 @@ public abstract class SignatureVisitor { /** * The ASM API version implemented by this visitor. The value of this field - * must be one of {@link Opcodes#ASM4}. + * must be one of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. */ protected final int api; @@ -82,9 +82,12 @@ public abstract class SignatureVisitor { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. */ public SignatureVisitor(final int api) { + if (api != Opcodes.ASM4 && api != Opcodes.ASM5) { + throw new IllegalArgumentException(); + } this.api = api; } diff --git a/src/asm/scala/tools/asm/signature/SignatureWriter.java b/src/asm/scala/tools/asm/signature/SignatureWriter.java index ebf4fe07b4ec..65756eee510b 100644 --- a/src/asm/scala/tools/asm/signature/SignatureWriter.java +++ b/src/asm/scala/tools/asm/signature/SignatureWriter.java @@ -66,7 +66,7 @@ public class SignatureWriter extends SignatureVisitor { * Constructs a new {@link SignatureWriter} object. */ public SignatureWriter() { - super(Opcodes.ASM4); + super(Opcodes.ASM5); } // ------------------------------------------------------------------------ diff --git a/src/asm/scala/tools/asm/tree/AbstractInsnNode.java b/src/asm/scala/tools/asm/tree/AbstractInsnNode.java index 411eead3c794..2ce0c8b6ee2c 100644 --- a/src/asm/scala/tools/asm/tree/AbstractInsnNode.java +++ b/src/asm/scala/tools/asm/tree/AbstractInsnNode.java @@ -29,6 +29,7 @@ */ package scala.tools.asm.tree; +import java.util.ArrayList; import java.util.List; import java.util.Map; @@ -127,6 +128,28 @@ public abstract class AbstractInsnNode { */ protected int opcode; + /** + * The runtime visible type annotations of this instruction. This field is + * only used for real instructions (i.e. not for labels, frames, or line + * number nodes). This list is a list of {@link TypeAnnotationNode} objects. + * May be null. + * + * @associates scala.tools.asm.tree.TypeAnnotationNode + * @label visible + */ + public List visibleTypeAnnotations; + + /** + * The runtime invisible type annotations of this instruction. This field is + * only used for real instructions (i.e. not for labels, frames, or line + * number nodes). This list is a list of {@link TypeAnnotationNode} objects. + * May be null. + * + * @associates scala.tools.asm.tree.TypeAnnotationNode + * @label invisible + */ + public List invisibleTypeAnnotations; + /** * Previous instruction in the list to which this instruction belongs. */ @@ -203,6 +226,29 @@ public AbstractInsnNode getNext() { */ public abstract void accept(final MethodVisitor cv); + /** + * Makes the given visitor visit the annotations of this instruction. + * + * @param mv + * a method visitor. + */ + protected final void acceptAnnotations(final MethodVisitor mv) { + int n = visibleTypeAnnotations == null ? 0 : visibleTypeAnnotations + .size(); + for (int i = 0; i < n; ++i) { + TypeAnnotationNode an = visibleTypeAnnotations.get(i); + an.accept(mv.visitInsnAnnotation(an.typeRef, an.typePath, an.desc, + true)); + } + n = invisibleTypeAnnotations == null ? 0 : invisibleTypeAnnotations + .size(); + for (int i = 0; i < n; ++i) { + TypeAnnotationNode an = invisibleTypeAnnotations.get(i); + an.accept(mv.visitInsnAnnotation(an.typeRef, an.typePath, an.desc, + false)); + } + } + /** * Returns a copy of this instruction. * @@ -245,4 +291,36 @@ static LabelNode[] clone(final List labels, } return clones; } + + /** + * Clones the annotations of the given instruction into this instruction. + * + * @param insn + * the source instruction. + * @return this instruction. + */ + protected final AbstractInsnNode cloneAnnotations( + final AbstractInsnNode insn) { + if (insn.visibleTypeAnnotations != null) { + this.visibleTypeAnnotations = new ArrayList(); + for (int i = 0; i < insn.visibleTypeAnnotations.size(); ++i) { + TypeAnnotationNode src = insn.visibleTypeAnnotations.get(i); + TypeAnnotationNode ann = new TypeAnnotationNode(src.typeRef, + src.typePath, src.desc); + src.accept(ann); + this.visibleTypeAnnotations.add(ann); + } + } + if (insn.invisibleTypeAnnotations != null) { + this.invisibleTypeAnnotations = new ArrayList(); + for (int i = 0; i < insn.invisibleTypeAnnotations.size(); ++i) { + TypeAnnotationNode src = insn.invisibleTypeAnnotations.get(i); + TypeAnnotationNode ann = new TypeAnnotationNode(src.typeRef, + src.typePath, src.desc); + src.accept(ann); + this.invisibleTypeAnnotations.add(ann); + } + } + return this; + } } diff --git a/src/asm/scala/tools/asm/tree/AnnotationNode.java b/src/asm/scala/tools/asm/tree/AnnotationNode.java index 1f4beef9f754..b8d598806678 100644 --- a/src/asm/scala/tools/asm/tree/AnnotationNode.java +++ b/src/asm/scala/tools/asm/tree/AnnotationNode.java @@ -67,9 +67,14 @@ public class AnnotationNode extends AnnotationVisitor { * * @param desc * the class descriptor of the annotation class. + * @throws IllegalStateException + * If a subclass calls this constructor. */ public AnnotationNode(final String desc) { - this(Opcodes.ASM4, desc); + this(Opcodes.ASM5, desc); + if (getClass() != AnnotationNode.class) { + throw new IllegalStateException(); + } } /** @@ -77,7 +82,7 @@ public AnnotationNode(final String desc) { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. * @param desc * the class descriptor of the annotation class. */ @@ -93,7 +98,7 @@ public AnnotationNode(final int api, final String desc) { * where the visited values must be stored. */ AnnotationNode(final List values) { - super(Opcodes.ASM4); + super(Opcodes.ASM5); this.values = values; } @@ -166,7 +171,8 @@ public void visitEnd() { * versions of the ASM API than the given version. * * @param api - * an ASM API version. Must be one of {@link Opcodes#ASM4}. + * an ASM API version. Must be one of {@link Opcodes#ASM4} or + * {@link Opcodes#ASM5}. */ public void check(final int api) { // nothing to do diff --git a/src/asm/scala/tools/asm/tree/ClassNode.java b/src/asm/scala/tools/asm/tree/ClassNode.java index c3d999985a25..304b4ec9f5a0 100644 --- a/src/asm/scala/tools/asm/tree/ClassNode.java +++ b/src/asm/scala/tools/asm/tree/ClassNode.java @@ -39,6 +39,7 @@ import scala.tools.asm.FieldVisitor; import scala.tools.asm.MethodVisitor; import scala.tools.asm.Opcodes; +import scala.tools.asm.TypePath; /** * A node that represents a class. @@ -132,6 +133,24 @@ public class ClassNode extends ClassVisitor { */ public List invisibleAnnotations; + /** + * The runtime visible type annotations of this class. This list is a list + * of {@link TypeAnnotationNode} objects. May be null. + * + * @associates scala.tools.asm.tree.TypeAnnotationNode + * @label visible + */ + public List visibleTypeAnnotations; + + /** + * The runtime invisible type annotations of this class. This list is a list + * of {@link TypeAnnotationNode} objects. May be null. + * + * @associates scala.tools.asm.tree.TypeAnnotationNode + * @label invisible + */ + public List invisibleTypeAnnotations; + /** * The non standard attributes of this class. This list is a list of * {@link Attribute} objects. May be null. @@ -168,9 +187,15 @@ public class ClassNode extends ClassVisitor { * Constructs a new {@link ClassNode}. Subclasses must not use this * constructor. Instead, they must use the {@link #ClassNode(int)} * version. + * + * @throws IllegalStateException + * If a subclass calls this constructor. */ public ClassNode() { - this(Opcodes.ASM4); + this(Opcodes.ASM5); + if (getClass() != ClassNode.class) { + throw new IllegalStateException(); + } } /** @@ -178,7 +203,7 @@ public ClassNode() { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. */ public ClassNode(final int api) { super(api); @@ -238,6 +263,24 @@ public AnnotationVisitor visitAnnotation(final String desc, return an; } + @Override + public AnnotationVisitor visitTypeAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + TypeAnnotationNode an = new TypeAnnotationNode(typeRef, typePath, desc); + if (visible) { + if (visibleTypeAnnotations == null) { + visibleTypeAnnotations = new ArrayList(1); + } + visibleTypeAnnotations.add(an); + } else { + if (invisibleTypeAnnotations == null) { + invisibleTypeAnnotations = new ArrayList(1); + } + invisibleTypeAnnotations.add(an); + } + return an; + } + @Override public void visitAttribute(final Attribute attr) { if (attrs == null) { @@ -286,10 +329,26 @@ public void visitEnd() { * API than the given version. * * @param api - * an ASM API version. Must be one of {@link Opcodes#ASM4}. + * an ASM API version. Must be one of {@link Opcodes#ASM4} or + * {@link Opcodes#ASM5}. */ public void check(final int api) { - // nothing to do + if (api == Opcodes.ASM4) { + if (visibleTypeAnnotations != null + && visibleTypeAnnotations.size() > 0) { + throw new RuntimeException(); + } + if (invisibleTypeAnnotations != null + && invisibleTypeAnnotations.size() > 0) { + throw new RuntimeException(); + } + for (FieldNode f : fields) { + f.check(api); + } + for (MethodNode m : methods) { + m.check(api); + } + } } /** @@ -323,6 +382,19 @@ public void accept(final ClassVisitor cv) { AnnotationNode an = invisibleAnnotations.get(i); an.accept(cv.visitAnnotation(an.desc, false)); } + n = visibleTypeAnnotations == null ? 0 : visibleTypeAnnotations.size(); + for (i = 0; i < n; ++i) { + TypeAnnotationNode an = visibleTypeAnnotations.get(i); + an.accept(cv.visitTypeAnnotation(an.typeRef, an.typePath, an.desc, + true)); + } + n = invisibleTypeAnnotations == null ? 0 : invisibleTypeAnnotations + .size(); + for (i = 0; i < n; ++i) { + TypeAnnotationNode an = invisibleTypeAnnotations.get(i); + an.accept(cv.visitTypeAnnotation(an.typeRef, an.typePath, an.desc, + false)); + } n = attrs == null ? 0 : attrs.size(); for (i = 0; i < n; ++i) { cv.visitAttribute(attrs.get(i)); diff --git a/src/asm/scala/tools/asm/tree/FieldInsnNode.java b/src/asm/scala/tools/asm/tree/FieldInsnNode.java index 0c94f18adff3..c027de109bbe 100644 --- a/src/asm/scala/tools/asm/tree/FieldInsnNode.java +++ b/src/asm/scala/tools/asm/tree/FieldInsnNode.java @@ -97,12 +97,14 @@ public int getType() { } @Override - public void accept(final MethodVisitor cv) { - cv.visitFieldInsn(opcode, owner, name, desc); + public void accept(final MethodVisitor mv) { + mv.visitFieldInsn(opcode, owner, name, desc); + acceptAnnotations(mv); } @Override public AbstractInsnNode clone(final Map labels) { - return new FieldInsnNode(opcode, owner, name, desc); + return new FieldInsnNode(opcode, owner, name, desc) + .cloneAnnotations(this); } } diff --git a/src/asm/scala/tools/asm/tree/FieldNode.java b/src/asm/scala/tools/asm/tree/FieldNode.java index 61b614ec597d..3fb14dac4f16 100644 --- a/src/asm/scala/tools/asm/tree/FieldNode.java +++ b/src/asm/scala/tools/asm/tree/FieldNode.java @@ -37,6 +37,7 @@ import scala.tools.asm.ClassVisitor; import scala.tools.asm.FieldVisitor; import scala.tools.asm.Opcodes; +import scala.tools.asm.TypePath; /** * A node that represents a field. @@ -91,6 +92,24 @@ public class FieldNode extends FieldVisitor { */ public List invisibleAnnotations; + /** + * The runtime visible type annotations of this field. This list is a list + * of {@link TypeAnnotationNode} objects. May be null. + * + * @associates scala.tools.asm.tree.TypeAnnotationNode + * @label visible + */ + public List visibleTypeAnnotations; + + /** + * The runtime invisible type annotations of this field. This list is a list + * of {@link TypeAnnotationNode} objects. May be null. + * + * @associates scala.tools.asm.tree.TypeAnnotationNode + * @label invisible + */ + public List invisibleTypeAnnotations; + /** * The non standard attributes of this field. This list is a list of * {@link Attribute} objects. May be null. @@ -120,20 +139,24 @@ public class FieldNode extends FieldVisitor { * null if the field does not have an initial value, * must be an {@link Integer}, a {@link Float}, a {@link Long}, a * {@link Double} or a {@link String}. + * @throws IllegalStateException + * If a subclass calls this constructor. */ public FieldNode(final int access, final String name, final String desc, final String signature, final Object value) { - this(Opcodes.ASM4, access, name, desc, signature, value); + this(Opcodes.ASM5, access, name, desc, signature, value); + if (getClass() != FieldNode.class) { + throw new IllegalStateException(); + } } /** * Constructs a new {@link FieldNode}. Subclasses must not use this - * constructor. Instead, they must use the - * {@link #FieldNode(int, int, String, String, String, Object)} version. + * constructor. * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. * @param access * the field's access flags (see * {@link scala.tools.asm.Opcodes}). This parameter also @@ -183,6 +206,24 @@ public AnnotationVisitor visitAnnotation(final String desc, return an; } + @Override + public AnnotationVisitor visitTypeAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + TypeAnnotationNode an = new TypeAnnotationNode(typeRef, typePath, desc); + if (visible) { + if (visibleTypeAnnotations == null) { + visibleTypeAnnotations = new ArrayList(1); + } + visibleTypeAnnotations.add(an); + } else { + if (invisibleTypeAnnotations == null) { + invisibleTypeAnnotations = new ArrayList(1); + } + invisibleTypeAnnotations.add(an); + } + return an; + } + @Override public void visitAttribute(final Attribute attr) { if (attrs == null) { @@ -206,10 +247,20 @@ public void visitEnd() { * API than the given version. * * @param api - * an ASM API version. Must be one of {@link Opcodes#ASM4}. + * an ASM API version. Must be one of {@link Opcodes#ASM4} or + * {@link Opcodes#ASM5}. */ public void check(final int api) { - // nothing to do + if (api == Opcodes.ASM4) { + if (visibleTypeAnnotations != null + && visibleTypeAnnotations.size() > 0) { + throw new RuntimeException(); + } + if (invisibleTypeAnnotations != null + && invisibleTypeAnnotations.size() > 0) { + throw new RuntimeException(); + } + } } /** @@ -234,6 +285,19 @@ public void accept(final ClassVisitor cv) { AnnotationNode an = invisibleAnnotations.get(i); an.accept(fv.visitAnnotation(an.desc, false)); } + n = visibleTypeAnnotations == null ? 0 : visibleTypeAnnotations.size(); + for (i = 0; i < n; ++i) { + TypeAnnotationNode an = visibleTypeAnnotations.get(i); + an.accept(fv.visitTypeAnnotation(an.typeRef, an.typePath, an.desc, + true)); + } + n = invisibleTypeAnnotations == null ? 0 : invisibleTypeAnnotations + .size(); + for (i = 0; i < n; ++i) { + TypeAnnotationNode an = invisibleTypeAnnotations.get(i); + an.accept(fv.visitTypeAnnotation(an.typeRef, an.typePath, an.desc, + false)); + } n = attrs == null ? 0 : attrs.size(); for (i = 0; i < n; ++i) { fv.visitAttribute(attrs.get(i)); diff --git a/src/asm/scala/tools/asm/tree/IincInsnNode.java b/src/asm/scala/tools/asm/tree/IincInsnNode.java index f9adf2e38c1d..c37ac91c2741 100644 --- a/src/asm/scala/tools/asm/tree/IincInsnNode.java +++ b/src/asm/scala/tools/asm/tree/IincInsnNode.java @@ -73,10 +73,11 @@ public int getType() { @Override public void accept(final MethodVisitor mv) { mv.visitIincInsn(var, incr); + acceptAnnotations(mv); } @Override public AbstractInsnNode clone(final Map labels) { - return new IincInsnNode(var, incr); + return new IincInsnNode(var, incr).cloneAnnotations(this); } } diff --git a/src/asm/scala/tools/asm/tree/InsnList.java b/src/asm/scala/tools/asm/tree/InsnList.java index b1e2d97c6f81..e808712e7835 100644 --- a/src/asm/scala/tools/asm/tree/InsnList.java +++ b/src/asm/scala/tools/asm/tree/InsnList.java @@ -100,7 +100,7 @@ public AbstractInsnNode getLast() { * the index of the instruction that must be returned. * @return the instruction whose index is given. * @throws IndexOutOfBoundsException - * if (index < 0 || index >= size()). + * if (index < 0 || index >= size()). */ public AbstractInsnNode get(final int index) { if (index < 0 || index >= size) { @@ -535,6 +535,8 @@ private final class InsnListIterator implements ListIterator { AbstractInsnNode prev; + AbstractInsnNode remove; + InsnListIterator(int index) { if (index == size()) { next = null; @@ -556,12 +558,22 @@ public Object next() { AbstractInsnNode result = next; prev = result; next = result.next; + remove = result; return result; } public void remove() { - InsnList.this.remove(prev); - prev = prev.prev; + if (remove != null) { + if (remove == next) { + next = next.next; + } else { + prev = prev.prev; + } + InsnList.this.remove(remove); + remove = null; + } else { + throw new IllegalStateException(); + } } public boolean hasPrevious() { @@ -572,6 +584,7 @@ public Object previous() { AbstractInsnNode result = prev; next = result; prev = result.prev; + remove = result; return result; } @@ -598,6 +611,7 @@ public int previousIndex() { public void add(Object o) { InsnList.this.insertBefore(next, (AbstractInsnNode) o); prev = (AbstractInsnNode) o; + remove = null; } public void set(Object o) { diff --git a/src/asm/scala/tools/asm/tree/InsnNode.java b/src/asm/scala/tools/asm/tree/InsnNode.java index 4d5288cafa6d..f5313929ee06 100644 --- a/src/asm/scala/tools/asm/tree/InsnNode.java +++ b/src/asm/scala/tools/asm/tree/InsnNode.java @@ -78,10 +78,11 @@ public int getType() { @Override public void accept(final MethodVisitor mv) { mv.visitInsn(opcode); + acceptAnnotations(mv); } @Override public AbstractInsnNode clone(final Map labels) { - return new InsnNode(opcode); + return new InsnNode(opcode).cloneAnnotations(this); } } diff --git a/src/asm/scala/tools/asm/tree/IntInsnNode.java b/src/asm/scala/tools/asm/tree/IntInsnNode.java index e0aeed4bc83b..6bbe8d845cfa 100644 --- a/src/asm/scala/tools/asm/tree/IntInsnNode.java +++ b/src/asm/scala/tools/asm/tree/IntInsnNode.java @@ -78,10 +78,11 @@ public int getType() { @Override public void accept(final MethodVisitor mv) { mv.visitIntInsn(opcode, operand); + acceptAnnotations(mv); } @Override public AbstractInsnNode clone(final Map labels) { - return new IntInsnNode(opcode, operand); + return new IntInsnNode(opcode, operand).cloneAnnotations(this); } } diff --git a/src/asm/scala/tools/asm/tree/InvokeDynamicInsnNode.java b/src/asm/scala/tools/asm/tree/InvokeDynamicInsnNode.java index 7ee84b875b08..0f85e6029152 100644 --- a/src/asm/scala/tools/asm/tree/InvokeDynamicInsnNode.java +++ b/src/asm/scala/tools/asm/tree/InvokeDynamicInsnNode.java @@ -91,10 +91,12 @@ public int getType() { @Override public void accept(final MethodVisitor mv) { mv.visitInvokeDynamicInsn(name, desc, bsm, bsmArgs); + acceptAnnotations(mv); } @Override public AbstractInsnNode clone(final Map labels) { - return new InvokeDynamicInsnNode(name, desc, bsm, bsmArgs); + return new InvokeDynamicInsnNode(name, desc, bsm, bsmArgs) + .cloneAnnotations(this); } } diff --git a/src/asm/scala/tools/asm/tree/JumpInsnNode.java b/src/asm/scala/tools/asm/tree/JumpInsnNode.java index 81e1e09deb7f..8b8a769204a6 100644 --- a/src/asm/scala/tools/asm/tree/JumpInsnNode.java +++ b/src/asm/scala/tools/asm/tree/JumpInsnNode.java @@ -86,10 +86,12 @@ public int getType() { @Override public void accept(final MethodVisitor mv) { mv.visitJumpInsn(opcode, label.getLabel()); + acceptAnnotations(mv); } @Override public AbstractInsnNode clone(final Map labels) { - return new JumpInsnNode(opcode, clone(label, labels)); + return new JumpInsnNode(opcode, clone(label, labels)) + .cloneAnnotations(this); } } diff --git a/src/asm/scala/tools/asm/tree/LdcInsnNode.java b/src/asm/scala/tools/asm/tree/LdcInsnNode.java index 4e328f9b3934..1cc850bb31c5 100644 --- a/src/asm/scala/tools/asm/tree/LdcInsnNode.java +++ b/src/asm/scala/tools/asm/tree/LdcInsnNode.java @@ -69,10 +69,11 @@ public int getType() { @Override public void accept(final MethodVisitor mv) { mv.visitLdcInsn(cst); + acceptAnnotations(mv); } @Override public AbstractInsnNode clone(final Map labels) { - return new LdcInsnNode(cst); + return new LdcInsnNode(cst).cloneAnnotations(this); } } diff --git a/src/asm/scala/tools/asm/tree/LocalVariableAnnotationNode.java b/src/asm/scala/tools/asm/tree/LocalVariableAnnotationNode.java new file mode 100644 index 000000000000..d05b8081710d --- /dev/null +++ b/src/asm/scala/tools/asm/tree/LocalVariableAnnotationNode.java @@ -0,0 +1,157 @@ +/*** + * ASM: a very small and fast Java bytecode manipulation framework + * Copyright (c) 2000-2011 INRIA, France Telecom + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +package scala.tools.asm.tree; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import scala.tools.asm.Label; +import scala.tools.asm.MethodVisitor; +import scala.tools.asm.Opcodes; +import scala.tools.asm.TypePath; +import scala.tools.asm.TypeReference; + +/** + * A node that represents a type annotation on a local or resource variable. + * + * @author Eric Bruneton + */ +public class LocalVariableAnnotationNode extends TypeAnnotationNode { + + /** + * The fist instructions corresponding to the continuous ranges that make + * the scope of this local variable (inclusive). Must not be null. + */ + public List start; + + /** + * The last instructions corresponding to the continuous ranges that make + * the scope of this local variable (exclusive). This list must have the + * same size as the 'start' list. Must not be null. + */ + public List end; + + /** + * The local variable's index in each range. This list must have the same + * size as the 'start' list. Must not be null. + */ + public List index; + + /** + * Constructs a new {@link LocalVariableAnnotationNode}. Subclasses must + * not use this constructor. Instead, they must use the + * {@link #LocalVariableAnnotationNode(int, TypePath, LabelNode[], LabelNode[], int[], String)} + * version. + * + * @param typeRef + * a reference to the annotated type. See {@link TypeReference}. + * @param typePath + * the path to the annotated type argument, wildcard bound, array + * element type, or static inner type within 'typeRef'. May be + * null if the annotation targets 'typeRef' as a whole. + * @param start + * the fist instructions corresponding to the continuous ranges + * that make the scope of this local variable (inclusive). + * @param end + * the last instructions corresponding to the continuous ranges + * that make the scope of this local variable (exclusive). This + * array must have the same size as the 'start' array. + * @param index + * the local variable's index in each range. This array must have + * the same size as the 'start' array. + * @param desc + * the class descriptor of the annotation class. + */ + public LocalVariableAnnotationNode(int typeRef, TypePath typePath, + LabelNode[] start, LabelNode[] end, int[] index, String desc) { + this(Opcodes.ASM5, typeRef, typePath, start, end, index, desc); + } + + /** + * Constructs a new {@link LocalVariableAnnotationNode}. + * + * @param api + * the ASM API version implemented by this visitor. Must be one + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. + * @param typeRef + * a reference to the annotated type. See {@link TypeReference}. + * @param start + * the fist instructions corresponding to the continuous ranges + * that make the scope of this local variable (inclusive). + * @param end + * the last instructions corresponding to the continuous ranges + * that make the scope of this local variable (exclusive). This + * array must have the same size as the 'start' array. + * @param index + * the local variable's index in each range. This array must have + * the same size as the 'start' array. + * @param typePath + * the path to the annotated type argument, wildcard bound, array + * element type, or static inner type within 'typeRef'. May be + * null if the annotation targets 'typeRef' as a whole. + * @param desc + * the class descriptor of the annotation class. + */ + public LocalVariableAnnotationNode(int api, int typeRef, TypePath typePath, + LabelNode[] start, LabelNode[] end, int[] index, String desc) { + super(api, typeRef, typePath, desc); + this.start = new ArrayList(start.length); + this.start.addAll(Arrays.asList(start)); + this.end = new ArrayList(end.length); + this.end.addAll(Arrays.asList(end)); + this.index = new ArrayList(index.length); + for (int i : index) { + this.index.add(i); + } + } + + /** + * Makes the given visitor visit this type annotation. + * + * @param mv + * the visitor that must visit this annotation. + * @param visible + * true if the annotation is visible at runtime. + */ + public void accept(final MethodVisitor mv, boolean visible) { + Label[] start = new Label[this.start.size()]; + Label[] end = new Label[this.end.size()]; + int[] index = new int[this.index.size()]; + for (int i = 0; i < start.length; ++i) { + start[i] = this.start.get(i).getLabel(); + end[i] = this.end.get(i).getLabel(); + index[i] = this.index.get(i); + } + accept(mv.visitLocalVariableAnnotation(typeRef, typePath, start, end, + index, desc, true)); + } +} diff --git a/src/asm/scala/tools/asm/tree/LookupSwitchInsnNode.java b/src/asm/scala/tools/asm/tree/LookupSwitchInsnNode.java index d2479b481422..7db2f53ff43e 100644 --- a/src/asm/scala/tools/asm/tree/LookupSwitchInsnNode.java +++ b/src/asm/scala/tools/asm/tree/LookupSwitchInsnNode.java @@ -105,6 +105,7 @@ public void accept(final MethodVisitor mv) { labels[i] = this.labels.get(i).getLabel(); } mv.visitLookupSwitchInsn(dflt.getLabel(), keys, labels); + acceptAnnotations(mv); } @Override @@ -112,6 +113,6 @@ public AbstractInsnNode clone(final Map labels) { LookupSwitchInsnNode clone = new LookupSwitchInsnNode(clone(dflt, labels), null, clone(this.labels, labels)); clone.keys.addAll(keys); - return clone; + return clone.cloneAnnotations(this); } } diff --git a/src/asm/scala/tools/asm/tree/MethodInsnNode.java b/src/asm/scala/tools/asm/tree/MethodInsnNode.java index bf09f556d8f6..1ec46d473d64 100644 --- a/src/asm/scala/tools/asm/tree/MethodInsnNode.java +++ b/src/asm/scala/tools/asm/tree/MethodInsnNode.java @@ -32,6 +32,7 @@ import java.util.Map; import scala.tools.asm.MethodVisitor; +import scala.tools.asm.Opcodes; /** * A node that represents a method instruction. A method instruction is an @@ -57,6 +58,11 @@ public class MethodInsnNode extends AbstractInsnNode { */ public String desc; + /** + * If the method's owner class if an interface. + */ + public boolean itf; + /** * Constructs a new {@link MethodInsnNode}. * @@ -73,12 +79,37 @@ public class MethodInsnNode extends AbstractInsnNode { * @param desc * the method's descriptor (see {@link scala.tools.asm.Type}). */ + @Deprecated public MethodInsnNode(final int opcode, final String owner, final String name, final String desc) { + this(opcode, owner, name, desc, opcode == Opcodes.INVOKEINTERFACE); + } + + /** + * Constructs a new {@link MethodInsnNode}. + * + * @param opcode + * the opcode of the type instruction to be constructed. This + * opcode must be INVOKEVIRTUAL, INVOKESPECIAL, INVOKESTATIC or + * INVOKEINTERFACE. + * @param owner + * the internal name of the method's owner class (see + * {@link scala.tools.asm.Type#getInternalName() + * getInternalName}). + * @param name + * the method's name. + * @param desc + * the method's descriptor (see {@link scala.tools.asm.Type}). + * @param itf + * if the method's owner class is an interface. + */ + public MethodInsnNode(final int opcode, final String owner, + final String name, final String desc, final boolean itf) { super(opcode); this.owner = owner; this.name = name; this.desc = desc; + this.itf = itf; } /** @@ -99,11 +130,11 @@ public int getType() { @Override public void accept(final MethodVisitor mv) { - mv.visitMethodInsn(opcode, owner, name, desc); + mv.visitMethodInsn(opcode, owner, name, desc, itf); } @Override public AbstractInsnNode clone(final Map labels) { - return new MethodInsnNode(opcode, owner, name, desc); + return new MethodInsnNode(opcode, owner, name, desc, itf); } } diff --git a/src/asm/scala/tools/asm/tree/MethodNode.java b/src/asm/scala/tools/asm/tree/MethodNode.java index a161600edbc6..3dec50e02cab 100644 --- a/src/asm/scala/tools/asm/tree/MethodNode.java +++ b/src/asm/scala/tools/asm/tree/MethodNode.java @@ -41,6 +41,7 @@ import scala.tools.asm.MethodVisitor; import scala.tools.asm.Opcodes; import scala.tools.asm.Type; +import scala.tools.asm.TypePath; /** * A node that represents a method. @@ -77,6 +78,11 @@ public class MethodNode extends MethodVisitor { */ public List exceptions; + /** + * The method parameter info (access flags and name) + */ + public List parameters; + /** * The runtime visible annotations of this method. This list is a list of * {@link AnnotationNode} objects. May be null. @@ -95,6 +101,24 @@ public class MethodNode extends MethodVisitor { */ public List invisibleAnnotations; + /** + * The runtime visible type annotations of this method. This list is a list + * of {@link TypeAnnotationNode} objects. May be null. + * + * @associates scala.tools.asm.tree.TypeAnnotationNode + * @label visible + */ + public List visibleTypeAnnotations; + + /** + * The runtime invisible type annotations of this method. This list is a + * list of {@link TypeAnnotationNode} objects. May be null. + * + * @associates scala.tools.asm.tree.TypeAnnotationNode + * @label invisible + */ + public List invisibleTypeAnnotations; + /** * The non standard attributes of this method. This list is a list of * {@link Attribute} objects. May be null. @@ -166,6 +190,22 @@ public class MethodNode extends MethodVisitor { */ public List localVariables; + /** + * The visible local variable annotations of this method. This list is a + * list of {@link LocalVariableAnnotationNode} objects. May be null + * + * @associates scala.tools.asm.tree.LocalVariableAnnotationNode + */ + public List visibleLocalVariableAnnotations; + + /** + * The invisible local variable annotations of this method. This list is a + * list of {@link LocalVariableAnnotationNode} objects. May be null + * + * @associates scala.tools.asm.tree.LocalVariableAnnotationNode + */ + public List invisibleLocalVariableAnnotations; + /** * If the accept method has been called on this object. */ @@ -175,9 +215,15 @@ public class MethodNode extends MethodVisitor { * Constructs an uninitialized {@link MethodNode}. Subclasses must not * use this constructor. Instead, they must use the * {@link #MethodNode(int)} version. + * + * @throws IllegalStateException + * If a subclass calls this constructor. */ public MethodNode() { - this(Opcodes.ASM4); + this(Opcodes.ASM5); + if (getClass() != MethodNode.class) { + throw new IllegalStateException(); + } } /** @@ -185,7 +231,7 @@ public MethodNode() { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. */ public MethodNode(final int api) { super(api); @@ -211,10 +257,15 @@ public MethodNode(final int api) { * the internal names of the method's exception classes (see * {@link Type#getInternalName() getInternalName}). May be * null. + * @throws IllegalStateException + * If a subclass calls this constructor. */ public MethodNode(final int access, final String name, final String desc, final String signature, final String[] exceptions) { - this(Opcodes.ASM4, access, name, desc, signature, exceptions); + this(Opcodes.ASM5, access, name, desc, signature, exceptions); + if (getClass() != MethodNode.class) { + throw new IllegalStateException(); + } } /** @@ -222,7 +273,7 @@ public MethodNode(final int access, final String name, final String desc, * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. * @param access * the method's access flags (see {@link Opcodes}). This * parameter also indicates if the method is synthetic and/or @@ -263,6 +314,15 @@ public MethodNode(final int api, final int access, final String name, // ------------------------------------------------------------------------ @Override + public void visitParameter(String name, int access) { + if (parameters == null) { + parameters = new ArrayList(5); + } + parameters.add(new ParameterNode(name, access)); + } + + @Override + @SuppressWarnings("serial") public AnnotationVisitor visitAnnotationDefault() { return new AnnotationNode(new ArrayList(0) { @Override @@ -291,6 +351,24 @@ public AnnotationVisitor visitAnnotation(final String desc, return an; } + @Override + public AnnotationVisitor visitTypeAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + TypeAnnotationNode an = new TypeAnnotationNode(typeRef, typePath, desc); + if (visible) { + if (visibleTypeAnnotations == null) { + visibleTypeAnnotations = new ArrayList(1); + } + visibleTypeAnnotations.add(an); + } else { + if (invisibleTypeAnnotations == null) { + invisibleTypeAnnotations = new ArrayList(1); + } + invisibleTypeAnnotations.add(an); + } + return an; + } + @Override public AnnotationVisitor visitParameterAnnotation(final int parameter, final String desc, final boolean visible) { @@ -365,12 +443,27 @@ public void visitFieldInsn(final int opcode, final String owner, instructions.add(new FieldInsnNode(opcode, owner, name, desc)); } + @Deprecated @Override - public void visitMethodInsn(final int opcode, final String owner, - final String name, final String desc) { + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (api >= Opcodes.ASM5) { + super.visitMethodInsn(opcode, owner, name, desc); + return; + } instructions.add(new MethodInsnNode(opcode, owner, name, desc)); } + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc, boolean itf) { + if (api < Opcodes.ASM5) { + super.visitMethodInsn(opcode, owner, name, desc, itf); + return; + } + instructions.add(new MethodInsnNode(opcode, owner, name, desc, itf)); + } + @Override public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, Object... bsmArgs) { @@ -416,6 +509,33 @@ public void visitMultiANewArrayInsn(final String desc, final int dims) { instructions.add(new MultiANewArrayInsnNode(desc, dims)); } + @Override + public AnnotationVisitor visitInsnAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + // Finds the last real instruction, i.e. the instruction targeted by + // this annotation. + AbstractInsnNode insn = instructions.getLast(); + while (insn.getOpcode() == -1) { + insn = insn.getPrevious(); + } + // Adds the annotation to this instruction. + TypeAnnotationNode an = new TypeAnnotationNode(typeRef, typePath, desc); + if (visible) { + if (insn.visibleTypeAnnotations == null) { + insn.visibleTypeAnnotations = new ArrayList( + 1); + } + insn.visibleTypeAnnotations.add(an); + } else { + if (insn.invisibleTypeAnnotations == null) { + insn.invisibleTypeAnnotations = new ArrayList( + 1); + } + insn.invisibleTypeAnnotations.add(an); + } + return an; + } + @Override public void visitTryCatchBlock(final Label start, final Label end, final Label handler, final String type) { @@ -423,6 +543,27 @@ public void visitTryCatchBlock(final Label start, final Label end, getLabelNode(end), getLabelNode(handler), type)); } + @Override + public AnnotationVisitor visitTryCatchAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + TryCatchBlockNode tcb = tryCatchBlocks.get((typeRef & 0x00FFFF00) >> 8); + TypeAnnotationNode an = new TypeAnnotationNode(typeRef, typePath, desc); + if (visible) { + if (tcb.visibleTypeAnnotations == null) { + tcb.visibleTypeAnnotations = new ArrayList( + 1); + } + tcb.visibleTypeAnnotations.add(an); + } else { + if (tcb.invisibleTypeAnnotations == null) { + tcb.invisibleTypeAnnotations = new ArrayList( + 1); + } + tcb.invisibleTypeAnnotations.add(an); + } + return an; + } + @Override public void visitLocalVariable(final String name, final String desc, final String signature, final Label start, final Label end, @@ -431,6 +572,29 @@ public void visitLocalVariable(final String name, final String desc, getLabelNode(start), getLabelNode(end), index)); } + @Override + public AnnotationVisitor visitLocalVariableAnnotation(int typeRef, + TypePath typePath, Label[] start, Label[] end, int[] index, + String desc, boolean visible) { + LocalVariableAnnotationNode an = new LocalVariableAnnotationNode( + typeRef, typePath, getLabelNodes(start), getLabelNodes(end), + index, desc); + if (visible) { + if (visibleLocalVariableAnnotations == null) { + visibleLocalVariableAnnotations = new ArrayList( + 1); + } + visibleLocalVariableAnnotations.add(an); + } else { + if (invisibleLocalVariableAnnotations == null) { + invisibleLocalVariableAnnotations = new ArrayList( + 1); + } + invisibleLocalVariableAnnotations.add(an); + } + return an; + } + @Override public void visitLineNumber(final int line, final Label start) { instructions.add(new LineNumberNode(line, getLabelNode(start))); @@ -494,10 +658,57 @@ private Object[] getLabelNodes(final Object[] objs) { * versions of the ASM API than the given version. * * @param api - * an ASM API version. Must be one of {@link Opcodes#ASM4}. + * an ASM API version. Must be one of {@link Opcodes#ASM4} or + * {@link Opcodes#ASM5}. */ public void check(final int api) { - // nothing to do + if (api == Opcodes.ASM4) { + if (visibleTypeAnnotations != null + && visibleTypeAnnotations.size() > 0) { + throw new RuntimeException(); + } + if (invisibleTypeAnnotations != null + && invisibleTypeAnnotations.size() > 0) { + throw new RuntimeException(); + } + int n = tryCatchBlocks == null ? 0 : tryCatchBlocks.size(); + for (int i = 0; i < n; ++i) { + TryCatchBlockNode tcb = tryCatchBlocks.get(i); + if (tcb.visibleTypeAnnotations != null + && tcb.visibleTypeAnnotations.size() > 0) { + throw new RuntimeException(); + } + if (tcb.invisibleTypeAnnotations != null + && tcb.invisibleTypeAnnotations.size() > 0) { + throw new RuntimeException(); + } + } + for (int i = 0; i < instructions.size(); ++i) { + AbstractInsnNode insn = instructions.get(i); + if (insn.visibleTypeAnnotations != null + && insn.visibleTypeAnnotations.size() > 0) { + throw new RuntimeException(); + } + if (insn.invisibleTypeAnnotations != null + && insn.invisibleTypeAnnotations.size() > 0) { + throw new RuntimeException(); + } + if (insn instanceof MethodInsnNode) { + boolean itf = ((MethodInsnNode) insn).itf; + if (itf != (insn.opcode == Opcodes.INVOKEINTERFACE)) { + throw new RuntimeException(); + } + } + } + if (visibleLocalVariableAnnotations != null + && visibleLocalVariableAnnotations.size() > 0) { + throw new RuntimeException(); + } + if (invisibleLocalVariableAnnotations != null + && invisibleLocalVariableAnnotations.size() > 0) { + throw new RuntimeException(); + } + } } /** @@ -523,8 +734,14 @@ public void accept(final ClassVisitor cv) { * a method visitor. */ public void accept(final MethodVisitor mv) { - // visits the method attributes + // visits the method parameters int i, j, n; + n = parameters == null ? 0 : parameters.size(); + for (i = 0; i < n; i++) { + ParameterNode parameter = parameters.get(i); + mv.visitParameter(parameter.name, parameter.access); + } + // visits the method attributes if (annotationDefault != null) { AnnotationVisitor av = mv.visitAnnotationDefault(); AnnotationNode.accept(av, null, annotationDefault); @@ -542,6 +759,19 @@ public void accept(final MethodVisitor mv) { AnnotationNode an = invisibleAnnotations.get(i); an.accept(mv.visitAnnotation(an.desc, false)); } + n = visibleTypeAnnotations == null ? 0 : visibleTypeAnnotations.size(); + for (i = 0; i < n; ++i) { + TypeAnnotationNode an = visibleTypeAnnotations.get(i); + an.accept(mv.visitTypeAnnotation(an.typeRef, an.typePath, an.desc, + true)); + } + n = invisibleTypeAnnotations == null ? 0 : invisibleTypeAnnotations + .size(); + for (i = 0; i < n; ++i) { + TypeAnnotationNode an = invisibleTypeAnnotations.get(i); + an.accept(mv.visitTypeAnnotation(an.typeRef, an.typePath, an.desc, + false)); + } n = visibleParameterAnnotations == null ? 0 : visibleParameterAnnotations.length; for (i = 0; i < n; ++i) { @@ -579,6 +809,7 @@ public void accept(final MethodVisitor mv) { // visits try catch blocks n = tryCatchBlocks == null ? 0 : tryCatchBlocks.size(); for (i = 0; i < n; ++i) { + tryCatchBlocks.get(i).updateIndex(i); tryCatchBlocks.get(i).accept(mv); } // visits instructions @@ -588,6 +819,17 @@ public void accept(final MethodVisitor mv) { for (i = 0; i < n; ++i) { localVariables.get(i).accept(mv); } + // visits local variable annotations + n = visibleLocalVariableAnnotations == null ? 0 + : visibleLocalVariableAnnotations.size(); + for (i = 0; i < n; ++i) { + visibleLocalVariableAnnotations.get(i).accept(mv, true); + } + n = invisibleLocalVariableAnnotations == null ? 0 + : invisibleLocalVariableAnnotations.size(); + for (i = 0; i < n; ++i) { + invisibleLocalVariableAnnotations.get(i).accept(mv, false); + } // visits maxs mv.visitMaxs(maxStack, maxLocals); visited = true; diff --git a/src/asm/scala/tools/asm/tree/MultiANewArrayInsnNode.java b/src/asm/scala/tools/asm/tree/MultiANewArrayInsnNode.java index fe5e8832b300..a8339a20b50d 100644 --- a/src/asm/scala/tools/asm/tree/MultiANewArrayInsnNode.java +++ b/src/asm/scala/tools/asm/tree/MultiANewArrayInsnNode.java @@ -73,11 +73,12 @@ public int getType() { @Override public void accept(final MethodVisitor mv) { mv.visitMultiANewArrayInsn(desc, dims); + acceptAnnotations(mv); } @Override public AbstractInsnNode clone(final Map labels) { - return new MultiANewArrayInsnNode(desc, dims); + return new MultiANewArrayInsnNode(desc, dims).cloneAnnotations(this); } } diff --git a/src/asm/scala/tools/asm/tree/ParameterNode.java b/src/asm/scala/tools/asm/tree/ParameterNode.java new file mode 100644 index 000000000000..a3e55d562953 --- /dev/null +++ b/src/asm/scala/tools/asm/tree/ParameterNode.java @@ -0,0 +1,76 @@ +/*** + * ASM: a very small and fast Java bytecode manipulation framework + * Copyright (c) 2000-2011 INRIA, France Telecom + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ +package scala.tools.asm.tree; + +import scala.tools.asm.MethodVisitor; + +/** + * A node that represents a parameter access and name. + * + * @author Remi Forax + */ +public class ParameterNode { + /** + * The parameter's name. + */ + public String name; + + /** + * The parameter's access flags (see {@link scala.tools.asm.Opcodes}). + * Valid values are ACC_FINAL, ACC_SYNTHETIC and + * ACC_MANDATED. + */ + public int access; + + /** + * Constructs a new {@link ParameterNode}. + * + * @param access + * The parameter's access flags. Valid values are + * ACC_FINAL, ACC_SYNTHETIC or/and + * ACC_MANDATED (see {@link scala.tools.asm.Opcodes}). + * @param name + * the parameter's name. + */ + public ParameterNode(final String name, final int access) { + this.name = name; + this.access = access; + } + + /** + * Makes the given visitor visit this parameter declaration. + * + * @param mv + * a method visitor. + */ + public void accept(final MethodVisitor mv) { + mv.visitParameter(name, access); + } +} diff --git a/src/asm/scala/tools/asm/tree/TableSwitchInsnNode.java b/src/asm/scala/tools/asm/tree/TableSwitchInsnNode.java index 9b3c2a3437cc..fb17b9e2e9a4 100644 --- a/src/asm/scala/tools/asm/tree/TableSwitchInsnNode.java +++ b/src/asm/scala/tools/asm/tree/TableSwitchInsnNode.java @@ -103,11 +103,12 @@ public void accept(final MethodVisitor mv) { labels[i] = this.labels.get(i).getLabel(); } mv.visitTableSwitchInsn(min, max, dflt.getLabel(), labels); + acceptAnnotations(mv); } @Override public AbstractInsnNode clone(final Map labels) { return new TableSwitchInsnNode(min, max, clone(dflt, labels), clone( - this.labels, labels)); + this.labels, labels)).cloneAnnotations(this); } } diff --git a/src/asm/scala/tools/asm/tree/TryCatchBlockNode.java b/src/asm/scala/tools/asm/tree/TryCatchBlockNode.java index ab4fa97c3489..c639b9aa8b5c 100644 --- a/src/asm/scala/tools/asm/tree/TryCatchBlockNode.java +++ b/src/asm/scala/tools/asm/tree/TryCatchBlockNode.java @@ -29,6 +29,8 @@ */ package scala.tools.asm.tree; +import java.util.List; + import scala.tools.asm.MethodVisitor; /** @@ -59,6 +61,26 @@ public class TryCatchBlockNode { */ public String type; + /** + * The runtime visible type annotations on the exception handler type. This + * list is a list of {@link TypeAnnotationNode} objects. May be + * null. + * + * @associates scala.tools.asm.tree.TypeAnnotationNode + * @label visible + */ + public List visibleTypeAnnotations; + + /** + * The runtime invisible type annotations on the exception handler type. + * This list is a list of {@link TypeAnnotationNode} objects. May be + * null. + * + * @associates scala.tools.asm.tree.TypeAnnotationNode + * @label invisible + */ + public List invisibleTypeAnnotations; + /** * Constructs a new {@link TryCatchBlockNode}. * @@ -81,6 +103,29 @@ public TryCatchBlockNode(final LabelNode start, final LabelNode end, this.type = type; } + /** + * Updates the index of this try catch block in the method's list of try + * catch block nodes. This index maybe stored in the 'target' field of the + * type annotations of this block. + * + * @param index + * the new index of this try catch block in the method's list of + * try catch block nodes. + */ + public void updateIndex(final int index) { + int newTypeRef = 0x42000000 | (index << 8); + if (visibleTypeAnnotations != null) { + for (TypeAnnotationNode tan : visibleTypeAnnotations) { + tan.typeRef = newTypeRef; + } + } + if (invisibleTypeAnnotations != null) { + for (TypeAnnotationNode tan : invisibleTypeAnnotations) { + tan.typeRef = newTypeRef; + } + } + } + /** * Makes the given visitor visit this try catch block. * @@ -90,5 +135,19 @@ public TryCatchBlockNode(final LabelNode start, final LabelNode end, public void accept(final MethodVisitor mv) { mv.visitTryCatchBlock(start.getLabel(), end.getLabel(), handler == null ? null : handler.getLabel(), type); + int n = visibleTypeAnnotations == null ? 0 : visibleTypeAnnotations + .size(); + for (int i = 0; i < n; ++i) { + TypeAnnotationNode an = visibleTypeAnnotations.get(i); + an.accept(mv.visitTryCatchAnnotation(an.typeRef, an.typePath, + an.desc, true)); + } + n = invisibleTypeAnnotations == null ? 0 : invisibleTypeAnnotations + .size(); + for (int i = 0; i < n; ++i) { + TypeAnnotationNode an = invisibleTypeAnnotations.get(i); + an.accept(mv.visitTryCatchAnnotation(an.typeRef, an.typePath, + an.desc, false)); + } } } diff --git a/src/asm/scala/tools/asm/tree/TypeAnnotationNode.java b/src/asm/scala/tools/asm/tree/TypeAnnotationNode.java new file mode 100644 index 000000000000..73b29624f7b8 --- /dev/null +++ b/src/asm/scala/tools/asm/tree/TypeAnnotationNode.java @@ -0,0 +1,100 @@ +/*** + * ASM: a very small and fast Java bytecode manipulation framework + * Copyright (c) 2000-2011 INRIA, France Telecom + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ +package scala.tools.asm.tree; + +import scala.tools.asm.Opcodes; +import scala.tools.asm.TypePath; +import scala.tools.asm.TypeReference; + +/** + * A node that represents a type annotationn. + * + * @author Eric Bruneton + */ +public class TypeAnnotationNode extends AnnotationNode { + + /** + * A reference to the annotated type. See {@link TypeReference}. + */ + public int typeRef; + + /** + * The path to the annotated type argument, wildcard bound, array element + * type, or static outer type within the referenced type. May be + * null if the annotation targets 'typeRef' as a whole. + */ + public TypePath typePath; + + /** + * Constructs a new {@link AnnotationNode}. Subclasses must not use this + * constructor. Instead, they must use the + * {@link #TypeAnnotationNode(int, int, TypePath, String)} version. + * + * @param typeRef + * a reference to the annotated type. See {@link TypeReference}. + * @param typePath + * the path to the annotated type argument, wildcard bound, array + * element type, or static inner type within 'typeRef'. May be + * null if the annotation targets 'typeRef' as a whole. + * @param desc + * the class descriptor of the annotation class. + * @throws IllegalStateException + * If a subclass calls this constructor. + */ + public TypeAnnotationNode(final int typeRef, final TypePath typePath, + final String desc) { + this(Opcodes.ASM5, typeRef, typePath, desc); + if (getClass() != TypeAnnotationNode.class) { + throw new IllegalStateException(); + } + } + + /** + * Constructs a new {@link AnnotationNode}. + * + * @param api + * the ASM API version implemented by this visitor. Must be one + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. + * @param typeRef + * a reference to the annotated type. See {@link TypeReference}. + * @param typePath + * the path to the annotated type argument, wildcard bound, array + * element type, or static inner type within 'typeRef'. May be + * null if the annotation targets 'typeRef' as a whole. + * @param desc + * the class descriptor of the annotation class. + */ + public TypeAnnotationNode(final int api, final int typeRef, + final TypePath typePath, final String desc) { + super(api, desc); + this.typeRef = typeRef; + this.typePath = typePath; + } +} diff --git a/src/asm/scala/tools/asm/tree/TypeInsnNode.java b/src/asm/scala/tools/asm/tree/TypeInsnNode.java index 3210dd60e624..401400c3cbad 100644 --- a/src/asm/scala/tools/asm/tree/TypeInsnNode.java +++ b/src/asm/scala/tools/asm/tree/TypeInsnNode.java @@ -81,10 +81,11 @@ public int getType() { @Override public void accept(final MethodVisitor mv) { mv.visitTypeInsn(opcode, desc); + acceptAnnotations(mv); } @Override public AbstractInsnNode clone(final Map labels) { - return new TypeInsnNode(opcode, desc); + return new TypeInsnNode(opcode, desc).cloneAnnotations(this); } } diff --git a/src/asm/scala/tools/asm/tree/VarInsnNode.java b/src/asm/scala/tools/asm/tree/VarInsnNode.java index 5dd9ef67264a..685e4fce2cfc 100644 --- a/src/asm/scala/tools/asm/tree/VarInsnNode.java +++ b/src/asm/scala/tools/asm/tree/VarInsnNode.java @@ -84,10 +84,11 @@ public int getType() { @Override public void accept(final MethodVisitor mv) { mv.visitVarInsn(opcode, var); + acceptAnnotations(mv); } @Override public AbstractInsnNode clone(final Map labels) { - return new VarInsnNode(opcode, var); + return new VarInsnNode(opcode, var).cloneAnnotations(this); } } diff --git a/src/asm/scala/tools/asm/tree/analysis/AnalyzerException.java b/src/asm/scala/tools/asm/tree/analysis/AnalyzerException.java index 5e3f51f21ad4..52b2a11d6f39 100644 --- a/src/asm/scala/tools/asm/tree/analysis/AnalyzerException.java +++ b/src/asm/scala/tools/asm/tree/analysis/AnalyzerException.java @@ -37,6 +37,7 @@ * @author Bing Ran * @author Eric Bruneton */ +@SuppressWarnings("serial") public class AnalyzerException extends Exception { public final AbstractInsnNode node; diff --git a/src/asm/scala/tools/asm/tree/analysis/BasicInterpreter.java b/src/asm/scala/tools/asm/tree/analysis/BasicInterpreter.java index 8d6653c1c545..7d0b7b0694bd 100644 --- a/src/asm/scala/tools/asm/tree/analysis/BasicInterpreter.java +++ b/src/asm/scala/tools/asm/tree/analysis/BasicInterpreter.java @@ -53,7 +53,7 @@ public class BasicInterpreter extends Interpreter implements Opcodes { public BasicInterpreter() { - super(ASM4); + super(ASM5); } protected BasicInterpreter(final int api) { diff --git a/src/asm/scala/tools/asm/tree/analysis/BasicVerifier.java b/src/asm/scala/tools/asm/tree/analysis/BasicVerifier.java index 71666edb7498..b852f20acf3b 100644 --- a/src/asm/scala/tools/asm/tree/analysis/BasicVerifier.java +++ b/src/asm/scala/tools/asm/tree/analysis/BasicVerifier.java @@ -47,7 +47,7 @@ public class BasicVerifier extends BasicInterpreter { public BasicVerifier() { - super(ASM4); + super(ASM5); } protected BasicVerifier(final int api) { diff --git a/src/asm/scala/tools/asm/tree/analysis/Frame.java b/src/asm/scala/tools/asm/tree/analysis/Frame.java index 0d92edc4d671..44a07ee27c1f 100644 --- a/src/asm/scala/tools/asm/tree/analysis/Frame.java +++ b/src/asm/scala/tools/asm/tree/analysis/Frame.java @@ -133,6 +133,15 @@ public int getLocals() { return locals; } + /** + * Returns the maximum stack size of this frame. + * + * @return the maximum stack size of this frame. + */ + public int getMaxStackSize() { + return values.length - locals; + } + /** * Returns the value of the given local variable. * diff --git a/src/asm/scala/tools/asm/tree/analysis/SimpleVerifier.java b/src/asm/scala/tools/asm/tree/analysis/SimpleVerifier.java index eaecd057eafb..a345981f367b 100644 --- a/src/asm/scala/tools/asm/tree/analysis/SimpleVerifier.java +++ b/src/asm/scala/tools/asm/tree/analysis/SimpleVerifier.java @@ -107,7 +107,7 @@ public SimpleVerifier(final Type currentClass, public SimpleVerifier(final Type currentClass, final Type currentSuperClass, final List currentClassInterfaces, final boolean isInterface) { - this(ASM4, currentClass, currentSuperClass, currentClassInterfaces, + this(ASM5, currentClass, currentSuperClass, currentClassInterfaces, isInterface); } diff --git a/src/asm/scala/tools/asm/tree/analysis/SourceInterpreter.java b/src/asm/scala/tools/asm/tree/analysis/SourceInterpreter.java index a68086c07303..7d739d3df9f4 100644 --- a/src/asm/scala/tools/asm/tree/analysis/SourceInterpreter.java +++ b/src/asm/scala/tools/asm/tree/analysis/SourceInterpreter.java @@ -50,7 +50,7 @@ public class SourceInterpreter extends Interpreter implements Opcodes { public SourceInterpreter() { - super(ASM4); + super(ASM5); } protected SourceInterpreter(final int api) { diff --git a/src/asm/scala/tools/asm/util/ASMifier.java b/src/asm/scala/tools/asm/util/ASMifier.java index 7e6b223853c9..521e07541b3c 100644 --- a/src/asm/scala/tools/asm/util/ASMifier.java +++ b/src/asm/scala/tools/asm/util/ASMifier.java @@ -40,6 +40,7 @@ import scala.tools.asm.Label; import scala.tools.asm.Opcodes; import scala.tools.asm.Type; +import scala.tools.asm.TypePath; /** * A {@link Printer} that prints the ASM code to generate the classes if visits. @@ -83,9 +84,15 @@ public class ASMifier extends Printer { * Constructs a new {@link ASMifier}. Subclasses must not use this * constructor. Instead, they must use the * {@link #ASMifier(int, String, int)} version. + * + * @throws IllegalStateException + * If a subclass calls this constructor. */ public ASMifier() { - this(Opcodes.ASM4, "cw", 0); + this(Opcodes.ASM5, "cw", 0); + if (getClass() != ASMifier.class) { + throw new IllegalStateException(); + } } /** @@ -93,7 +100,7 @@ public ASMifier() { * * @param api * the ASM API version implemented by this class. Must be one of - * {@link Opcodes#ASM4}. + * {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. * @param name * the name of the visitor variable in the produced code. * @param id @@ -170,7 +177,6 @@ public void visit(final int version, final int access, final String name, } text.add("import java.util.*;\n"); text.add("import scala.tools.asm.*;\n"); - text.add("import scala.tools.asm.attrs.*;\n"); text.add("public class " + simpleName + "Dump implements Opcodes {\n\n"); text.add("public static byte[] dump () throws Exception {\n\n"); text.add("ClassWriter cw = new ClassWriter(0);\n"); @@ -260,6 +266,12 @@ public ASMifier visitClassAnnotation(final String desc, return visitAnnotation(desc, visible); } + @Override + public ASMifier visitClassTypeAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + return visitTypeAnnotation(typeRef, typePath, desc, visible); + } + @Override public void visitClassAttribute(final Attribute attr) { visitAttribute(attr); @@ -422,6 +434,12 @@ public ASMifier visitFieldAnnotation(final String desc, return visitAnnotation(desc, visible); } + @Override + public ASMifier visitFieldTypeAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + return visitTypeAnnotation(typeRef, typePath, desc, visible); + } + @Override public void visitFieldAttribute(final Attribute attr) { visitAttribute(attr); @@ -438,6 +456,16 @@ public void visitFieldEnd() { // Methods // ------------------------------------------------------------------------ + @Override + public void visitParameter(String parameterName, int access) { + buf.setLength(0); + buf.append(name).append(".visitParameter("); + appendString(buf, parameterName); + buf.append(", "); + appendAccess(access); + text.add(buf.append(");\n").toString()); + } + @Override public ASMifier visitAnnotationDefault() { buf.setLength(0); @@ -456,6 +484,12 @@ public ASMifier visitMethodAnnotation(final String desc, return visitAnnotation(desc, visible); } + @Override + public ASMifier visitMethodTypeAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + return visitTypeAnnotation(typeRef, typePath, desc, visible); + } + @Override public ASMifier visitParameterAnnotation(final int parameter, final String desc, final boolean visible) { @@ -582,9 +616,30 @@ public void visitFieldInsn(final int opcode, final String owner, text.add(buf.toString()); } + @Deprecated @Override public void visitMethodInsn(final int opcode, final String owner, final String name, final String desc) { + if (api >= Opcodes.ASM5) { + super.visitMethodInsn(opcode, owner, name, desc); + return; + } + doVisitMethodInsn(opcode, owner, name, desc, + opcode == Opcodes.INVOKEINTERFACE); + } + + @Override + public void visitMethodInsn(final int opcode, final String owner, + final String name, final String desc, final boolean itf) { + if (api < Opcodes.ASM5) { + super.visitMethodInsn(opcode, owner, name, desc, itf); + return; + } + doVisitMethodInsn(opcode, owner, name, desc, itf); + } + + private void doVisitMethodInsn(final int opcode, final String owner, + final String name, final String desc, final boolean itf) { buf.setLength(0); buf.append(this.name).append(".visitMethodInsn(") .append(OPCODES[opcode]).append(", "); @@ -593,6 +648,8 @@ public void visitMethodInsn(final int opcode, final String owner, appendConstant(name); buf.append(", "); appendConstant(desc); + buf.append(", "); + buf.append(itf ? "true" : "false"); buf.append(");\n"); text.add(buf.toString()); } @@ -710,6 +767,13 @@ public void visitMultiANewArrayInsn(final String desc, final int dims) { text.add(buf.toString()); } + @Override + public ASMifier visitInsnAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + return visitTypeAnnotation("visitInsnAnnotation", typeRef, typePath, + desc, visible); + } + @Override public void visitTryCatchBlock(final Label start, final Label end, final Label handler, final String type) { @@ -729,6 +793,13 @@ public void visitTryCatchBlock(final Label start, final Label end, text.add(buf.toString()); } + @Override + public ASMifier visitTryCatchAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + return visitTypeAnnotation("visitTryCatchAnnotation", typeRef, + typePath, desc, visible); + } + @Override public void visitLocalVariable(final String name, final String desc, final String signature, final Label start, final Label end, @@ -748,6 +819,39 @@ public void visitLocalVariable(final String name, final String desc, text.add(buf.toString()); } + @Override + public Printer visitLocalVariableAnnotation(int typeRef, TypePath typePath, + Label[] start, Label[] end, int[] index, String desc, + boolean visible) { + buf.setLength(0); + buf.append("{\n").append("av0 = ").append(name) + .append(".visitLocalVariableAnnotation("); + buf.append(typeRef); + buf.append(", TypePath.fromString(\"").append(typePath).append("\"), "); + buf.append("new Label[] {"); + for (int i = 0; i < start.length; ++i) { + buf.append(i == 0 ? " " : ", "); + appendLabel(start[i]); + } + buf.append(" }, new Label[] {"); + for (int i = 0; i < end.length; ++i) { + buf.append(i == 0 ? " " : ", "); + appendLabel(end[i]); + } + buf.append(" }, new int[] {"); + for (int i = 0; i < index.length; ++i) { + buf.append(i == 0 ? " " : ", ").append(index[i]); + } + buf.append(" }, "); + appendConstant(desc); + buf.append(", ").append(visible).append(");\n"); + text.add(buf.toString()); + ASMifier a = createASMifier("av", 0); + text.add(a.getText()); + text.add("}\n"); + return a; + } + @Override public void visitLineNumber(final int line, final Label start) { buf.setLength(0); @@ -789,6 +893,28 @@ public ASMifier visitAnnotation(final String desc, final boolean visible) { return a; } + public ASMifier visitTypeAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + return visitTypeAnnotation("visitTypeAnnotation", typeRef, typePath, + desc, visible); + } + + public ASMifier visitTypeAnnotation(final String method, final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + buf.setLength(0); + buf.append("{\n").append("av0 = ").append(name).append(".") + .append(method).append("("); + buf.append(typeRef); + buf.append(", TypePath.fromString(\"").append(typePath).append("\"), "); + appendConstant(desc); + buf.append(", ").append(visible).append(");\n"); + text.add(buf.toString()); + ASMifier a = createASMifier("av", 0); + text.add(a.getText()); + text.add("}\n"); + return a; + } + public void visitAttribute(final Attribute attr) { buf.setLength(0); buf.append("// ATTRIBUTE ").append(attr.type).append('\n'); @@ -809,7 +935,7 @@ public void visitAttribute(final Attribute attr) { // ------------------------------------------------------------------------ protected ASMifier createASMifier(final String name, final int id) { - return new ASMifier(Opcodes.ASM4, name, id); + return new ASMifier(Opcodes.ASM5, name, id); } /** @@ -950,6 +1076,13 @@ void appendAccess(final int access) { buf.append("ACC_DEPRECATED"); first = false; } + if ((access & Opcodes.ACC_MANDATED) != 0) { + if (!first) { + buf.append(" + "); + } + buf.append("ACC_MANDATED"); + first = false; + } if (first) { buf.append('0'); } diff --git a/src/asm/scala/tools/asm/util/CheckAnnotationAdapter.java b/src/asm/scala/tools/asm/util/CheckAnnotationAdapter.java index f00a8f04a26e..70441d1df418 100644 --- a/src/asm/scala/tools/asm/util/CheckAnnotationAdapter.java +++ b/src/asm/scala/tools/asm/util/CheckAnnotationAdapter.java @@ -49,7 +49,7 @@ public CheckAnnotationAdapter(final AnnotationVisitor av) { } CheckAnnotationAdapter(final AnnotationVisitor av, final boolean named) { - super(Opcodes.ASM4, av); + super(Opcodes.ASM5, av); this.named = named; } @@ -70,7 +70,7 @@ public void visit(final String name, final Object value) { } if (value instanceof Type) { int sort = ((Type) value).getSort(); - if (sort != Type.OBJECT && sort != Type.ARRAY) { + if (sort == Type.METHOD) { throw new IllegalArgumentException("Invalid annotation value"); } } diff --git a/src/asm/scala/tools/asm/util/CheckClassAdapter.java b/src/asm/scala/tools/asm/util/CheckClassAdapter.java index 0bfa143a95df..9909208cc4af 100644 --- a/src/asm/scala/tools/asm/util/CheckClassAdapter.java +++ b/src/asm/scala/tools/asm/util/CheckClassAdapter.java @@ -46,6 +46,8 @@ import scala.tools.asm.MethodVisitor; import scala.tools.asm.Opcodes; import scala.tools.asm.Type; +import scala.tools.asm.TypePath; +import scala.tools.asm.TypeReference; import scala.tools.asm.tree.ClassNode; import scala.tools.asm.tree.MethodNode; import scala.tools.asm.tree.analysis.Analyzer; @@ -91,9 +93,9 @@ * insnNumber locals : stack): * * 
    - * scala.tools.asm.tree.analysis.AnalyzerException: Error at instruction 71: Expected I, but found .
- *   at scala.tools.asm.tree.analysis.Analyzer.analyze(Analyzer.java:289)
- *   at scala.tools.asm.util.CheckClassAdapter.verify(CheckClassAdapter.java:135)
+ * org.objectweb.asm.tree.analysis.AnalyzerException: Error at instruction 71: Expected I, but found .
+ *   at org.objectweb.asm.tree.analysis.Analyzer.analyze(Analyzer.java:289)
+ *   at org.objectweb.asm.util.CheckClassAdapter.verify(CheckClassAdapter.java:135)
  * ...
  * remove()V
  * 00000 LinkedBlockingQueue$Itr . . . . . . . .  :
@@ -106,7 +108,7 @@
  * 00071 LinkedBlockingQueue$Itr . I . . . . . .  :
  *   ILOAD 1
  * 00072 ?
- *   INVOKESPECIAL java/lang/Integer. (I)V
+ *   INVOKESPECIAL java/lang/Integer.<init> (I)V
  * ...
  *
    * @@ -215,7 +217,7 @@ public static void verify(final ClassReader cr, final ClassLoader loader, List interfaces = new ArrayList(); for (Iterator i = cn.interfaces.iterator(); i.hasNext();) { - interfaces.add(Type.getObjectType(i.next().toString())); + interfaces.add(Type.getObjectType(i.next())); } for (int i = 0; i < methods.size(); ++i) { @@ -328,9 +330,14 @@ public CheckClassAdapter(final ClassVisitor cv) { * false to not perform any data flow check (see * {@link CheckMethodAdapter}). This option requires valid * maxLocals and maxStack values. + * @throws IllegalStateException + * If a subclass calls this constructor. */ public CheckClassAdapter(final ClassVisitor cv, final boolean checkDataFlow) { - this(Opcodes.ASM4, cv, checkDataFlow); + this(Opcodes.ASM5, cv, checkDataFlow); + if (getClass() != CheckClassAdapter.class) { + throw new IllegalStateException(); + } } /** @@ -338,7 +345,7 @@ public CheckClassAdapter(final ClassVisitor cv, final boolean checkDataFlow) { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. * @param cv * the class visitor to which this adapter must delegate calls. * @param checkDataFlow @@ -440,7 +447,15 @@ public void visitInnerClass(final String name, final String outerName, CheckMethodAdapter.checkInternalName(outerName, "outer class name"); } if (innerName != null) { - CheckMethodAdapter.checkIdentifier(innerName, "inner class name"); + int start = 0; + while (start < innerName.length() + && Character.isDigit(innerName.charAt(start))) { + start++; + } + if (start == 0 || start < innerName.length()) { + CheckMethodAdapter.checkIdentifier(innerName, start, -1, + "inner class name"); + } } checkAccess(access, Opcodes.ACC_PUBLIC + Opcodes.ACC_PRIVATE + Opcodes.ACC_PROTECTED + Opcodes.ACC_STATIC @@ -516,6 +531,23 @@ public AnnotationVisitor visitAnnotation(final String desc, return new CheckAnnotationAdapter(super.visitAnnotation(desc, visible)); } + @Override + public AnnotationVisitor visitTypeAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + checkState(); + int sort = typeRef >>> 24; + if (sort != TypeReference.CLASS_TYPE_PARAMETER + && sort != TypeReference.CLASS_TYPE_PARAMETER_BOUND + && sort != TypeReference.CLASS_EXTENDS) { + throw new IllegalArgumentException("Invalid type reference sort 0x" + + Integer.toHexString(sort)); + } + checkTypeRefAndPath(typeRef, typePath); + CheckMethodAdapter.checkDesc(desc, false); + return new CheckAnnotationAdapter(super.visitTypeAnnotation(typeRef, + typePath, desc, visible)); + } + @Override public void visitAttribute(final Attribute attr) { checkState(); @@ -660,6 +692,77 @@ public static void checkFieldSignature(final String signature) { } } + /** + * Checks the reference to a type in a type annotation. + * + * @param typeRef + * a reference to an annotated type. + * @param typePath + * the path to the annotated type argument, wildcard bound, array + * element type, or static inner type within 'typeRef'. May be + * null if the annotation targets 'typeRef' as a whole. + */ + static void checkTypeRefAndPath(int typeRef, TypePath typePath) { + int mask = 0; + switch (typeRef >>> 24) { + case TypeReference.CLASS_TYPE_PARAMETER: + case TypeReference.METHOD_TYPE_PARAMETER: + case TypeReference.METHOD_FORMAL_PARAMETER: + mask = 0xFFFF0000; + break; + case TypeReference.FIELD: + case TypeReference.METHOD_RETURN: + case TypeReference.METHOD_RECEIVER: + case TypeReference.LOCAL_VARIABLE: + case TypeReference.RESOURCE_VARIABLE: + case TypeReference.INSTANCEOF: + case TypeReference.NEW: + case TypeReference.CONSTRUCTOR_REFERENCE: + case TypeReference.METHOD_REFERENCE: + mask = 0xFF000000; + break; + case TypeReference.CLASS_EXTENDS: + case TypeReference.CLASS_TYPE_PARAMETER_BOUND: + case TypeReference.METHOD_TYPE_PARAMETER_BOUND: + case TypeReference.THROWS: + case TypeReference.EXCEPTION_PARAMETER: + mask = 0xFFFFFF00; + break; + case TypeReference.CAST: + case TypeReference.CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT: + case TypeReference.METHOD_INVOCATION_TYPE_ARGUMENT: + case TypeReference.CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT: + case TypeReference.METHOD_REFERENCE_TYPE_ARGUMENT: + mask = 0xFF0000FF; + break; + default: + throw new IllegalArgumentException("Invalid type reference sort 0x" + + Integer.toHexString(typeRef >>> 24)); + } + if ((typeRef & ~mask) != 0) { + throw new IllegalArgumentException("Invalid type reference 0x" + + Integer.toHexString(typeRef)); + } + if (typePath != null) { + for (int i = 0; i < typePath.getLength(); ++i) { + int step = typePath.getStep(i); + if (step != TypePath.ARRAY_ELEMENT + && step != TypePath.INNER_TYPE + && step != TypePath.TYPE_ARGUMENT + && step != TypePath.WILDCARD_BOUND) { + throw new IllegalArgumentException( + "Invalid type path step " + i + " in " + typePath); + } + if (step != TypePath.TYPE_ARGUMENT + && typePath.getStepArgument(i) != 0) { + throw new IllegalArgumentException( + "Invalid type path step argument for step " + i + + " in " + typePath); + } + } + } + } + /** * Checks the formal type parameters of a class or method signature. * diff --git a/src/asm/scala/tools/asm/util/CheckFieldAdapter.java b/src/asm/scala/tools/asm/util/CheckFieldAdapter.java index 4657605936d7..e682df47aff2 100644 --- a/src/asm/scala/tools/asm/util/CheckFieldAdapter.java +++ b/src/asm/scala/tools/asm/util/CheckFieldAdapter.java @@ -33,6 +33,8 @@ import scala.tools.asm.Attribute; import scala.tools.asm.FieldVisitor; import scala.tools.asm.Opcodes; +import scala.tools.asm.TypePath; +import scala.tools.asm.TypeReference; /** * A {@link FieldVisitor} that checks that its methods are properly used. @@ -48,9 +50,14 @@ public class CheckFieldAdapter extends FieldVisitor { * * @param fv * the field visitor to which this adapter must delegate calls. + * @throws IllegalStateException + * If a subclass calls this constructor. */ public CheckFieldAdapter(final FieldVisitor fv) { - this(Opcodes.ASM4, fv); + this(Opcodes.ASM5, fv); + if (getClass() != CheckFieldAdapter.class) { + throw new IllegalStateException(); + } } /** @@ -58,7 +65,7 @@ public CheckFieldAdapter(final FieldVisitor fv) { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. * @param fv * the field visitor to which this adapter must delegate calls. */ @@ -74,6 +81,21 @@ public AnnotationVisitor visitAnnotation(final String desc, return new CheckAnnotationAdapter(super.visitAnnotation(desc, visible)); } + @Override + public AnnotationVisitor visitTypeAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + checkEnd(); + int sort = typeRef >>> 24; + if (sort != TypeReference.FIELD) { + throw new IllegalArgumentException("Invalid type reference sort 0x" + + Integer.toHexString(sort)); + } + CheckClassAdapter.checkTypeRefAndPath(typeRef, typePath); + CheckMethodAdapter.checkDesc(desc, false); + return new CheckAnnotationAdapter(super.visitTypeAnnotation(typeRef, + typePath, desc, visible)); + } + @Override public void visitAttribute(final Attribute attr) { checkEnd(); diff --git a/src/asm/scala/tools/asm/util/CheckMethodAdapter.java b/src/asm/scala/tools/asm/util/CheckMethodAdapter.java index 9da01c9d6efd..131dfa5e5b14 100644 --- a/src/asm/scala/tools/asm/util/CheckMethodAdapter.java +++ b/src/asm/scala/tools/asm/util/CheckMethodAdapter.java @@ -46,6 +46,8 @@ import scala.tools.asm.MethodVisitor; import scala.tools.asm.Opcodes; import scala.tools.asm.Type; +import scala.tools.asm.TypePath; +import scala.tools.asm.TypeReference; import scala.tools.asm.tree.MethodNode; import scala.tools.asm.tree.analysis.Analyzer; import scala.tools.asm.tree.analysis.BasicValue; @@ -390,10 +392,15 @@ public CheckMethodAdapter(final MethodVisitor mv) { * the method visitor to which this adapter must delegate calls. * @param labels * a map of already visited labels (in other methods). + * @throws IllegalStateException + * If a subclass calls this constructor. */ public CheckMethodAdapter(final MethodVisitor mv, final Map labels) { - this(Opcodes.ASM4, mv, labels); + this(Opcodes.ASM5, mv, labels); + if (getClass() != CheckMethodAdapter.class) { + throw new IllegalStateException(); + } } /** @@ -434,7 +441,7 @@ protected CheckMethodAdapter(final int api, final MethodVisitor mv, public CheckMethodAdapter(final int access, final String name, final String desc, final MethodVisitor cmv, final Map labels) { - this(new MethodNode(access, name, desc, null, null) { + this(new MethodNode(Opcodes.ASM5, access, name, desc, null, null) { @Override public void visitEnd() { Analyzer a = new Analyzer( @@ -461,6 +468,16 @@ public void visitEnd() { this.access = access; } + @Override + public void visitParameter(String name, int access) { + if (name != null) { + checkUnqualifiedName(version, name, "name"); + } + CheckClassAdapter.checkAccess(access, Opcodes.ACC_FINAL + + Opcodes.ACC_MANDATED + Opcodes.ACC_SYNTHETIC); + super.visitParameter(name, access); + } + @Override public AnnotationVisitor visitAnnotation(final String desc, final boolean visible) { @@ -469,6 +486,26 @@ public AnnotationVisitor visitAnnotation(final String desc, return new CheckAnnotationAdapter(super.visitAnnotation(desc, visible)); } + @Override + public AnnotationVisitor visitTypeAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + checkEndMethod(); + int sort = typeRef >>> 24; + if (sort != TypeReference.METHOD_TYPE_PARAMETER + && sort != TypeReference.METHOD_TYPE_PARAMETER_BOUND + && sort != TypeReference.METHOD_RETURN + && sort != TypeReference.METHOD_RECEIVER + && sort != TypeReference.METHOD_FORMAL_PARAMETER + && sort != TypeReference.THROWS) { + throw new IllegalArgumentException("Invalid type reference sort 0x" + + Integer.toHexString(sort)); + } + CheckClassAdapter.checkTypeRefAndPath(typeRef, typePath); + CheckMethodAdapter.checkDesc(desc, false); + return new CheckAnnotationAdapter(super.visitTypeAnnotation(typeRef, + typePath, desc, visible)); + } + @Override public AnnotationVisitor visitAnnotationDefault() { checkEndMethod(); @@ -647,9 +684,30 @@ public void visitFieldInsn(final int opcode, final String owner, ++insnCount; } + @Deprecated @Override - public void visitMethodInsn(final int opcode, final String owner, - final String name, final String desc) { + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (api >= Opcodes.ASM5) { + super.visitMethodInsn(opcode, owner, name, desc); + return; + } + doVisitMethodInsn(opcode, owner, name, desc, + opcode == Opcodes.INVOKEINTERFACE); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc, boolean itf) { + if (api < Opcodes.ASM5) { + super.visitMethodInsn(opcode, owner, name, desc, itf); + return; + } + doVisitMethodInsn(opcode, owner, name, desc, itf); + } + + private void doVisitMethodInsn(int opcode, final String owner, + final String name, final String desc, final boolean itf) { checkStartCode(); checkEndCode(); checkOpcode(opcode, 5); @@ -658,7 +716,21 @@ public void visitMethodInsn(final int opcode, final String owner, } checkInternalName(owner, "owner"); checkMethodDesc(desc); - super.visitMethodInsn(opcode, owner, name, desc); + if (opcode == Opcodes.INVOKEVIRTUAL && itf) { + throw new IllegalArgumentException( + "INVOKEVIRTUAL can't be used with interfaces"); + } + if (opcode == Opcodes.INVOKEINTERFACE && !itf) { + throw new IllegalArgumentException( + "INVOKEINTERFACE can't be used with classes"); + } + // Calling super.visitMethodInsn requires to call the correct version + // depending on this.api (otherwise infinite loops can occur). To + // simplify and to make it easier to automatically remove the backward + // compatibility code, we inline the code of the overridden method here. + if (mv != null) { + mv.visitMethodInsn(opcode, owner, name, desc, itf); + } ++insnCount; } @@ -796,6 +868,29 @@ public void visitMultiANewArrayInsn(final String desc, final int dims) { ++insnCount; } + @Override + public AnnotationVisitor visitInsnAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + checkStartCode(); + checkEndCode(); + int sort = typeRef >>> 24; + if (sort != TypeReference.INSTANCEOF && sort != TypeReference.NEW + && sort != TypeReference.CONSTRUCTOR_REFERENCE + && sort != TypeReference.METHOD_REFERENCE + && sort != TypeReference.CAST + && sort != TypeReference.CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT + && sort != TypeReference.METHOD_INVOCATION_TYPE_ARGUMENT + && sort != TypeReference.CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT + && sort != TypeReference.METHOD_REFERENCE_TYPE_ARGUMENT) { + throw new IllegalArgumentException("Invalid type reference sort 0x" + + Integer.toHexString(sort)); + } + CheckClassAdapter.checkTypeRefAndPath(typeRef, typePath); + CheckMethodAdapter.checkDesc(desc, false); + return new CheckAnnotationAdapter(super.visitInsnAnnotation(typeRef, + typePath, desc, visible)); + } + @Override public void visitTryCatchBlock(final Label start, final Label end, final Label handler, final String type) { @@ -820,6 +915,22 @@ public void visitTryCatchBlock(final Label start, final Label end, handlers.add(end); } + @Override + public AnnotationVisitor visitTryCatchAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + checkStartCode(); + checkEndCode(); + int sort = typeRef >>> 24; + if (sort != TypeReference.EXCEPTION_PARAMETER) { + throw new IllegalArgumentException("Invalid type reference sort 0x" + + Integer.toHexString(sort)); + } + CheckClassAdapter.checkTypeRefAndPath(typeRef, typePath); + CheckMethodAdapter.checkDesc(desc, false); + return new CheckAnnotationAdapter(super.visitTryCatchAnnotation( + typeRef, typePath, desc, visible)); + } + @Override public void visitLocalVariable(final String name, final String desc, final String signature, final Label start, final Label end, @@ -840,6 +951,40 @@ public void visitLocalVariable(final String name, final String desc, super.visitLocalVariable(name, desc, signature, start, end, index); } + @Override + public AnnotationVisitor visitLocalVariableAnnotation(int typeRef, + TypePath typePath, Label[] start, Label[] end, int[] index, + String desc, boolean visible) { + checkStartCode(); + checkEndCode(); + int sort = typeRef >>> 24; + if (sort != TypeReference.LOCAL_VARIABLE + && sort != TypeReference.RESOURCE_VARIABLE) { + throw new IllegalArgumentException("Invalid type reference sort 0x" + + Integer.toHexString(sort)); + } + CheckClassAdapter.checkTypeRefAndPath(typeRef, typePath); + checkDesc(desc, false); + if (start == null || end == null || index == null + || end.length != start.length || index.length != start.length) { + throw new IllegalArgumentException( + "Invalid start, end and index arrays (must be non null and of identical length"); + } + for (int i = 0; i < start.length; ++i) { + checkLabel(start[i], true, "start label"); + checkLabel(end[i], true, "end label"); + checkUnsignedShort(index[i], "Invalid variable index"); + int s = labels.get(start[i]).intValue(); + int e = labels.get(end[i]).intValue(); + if (e < s) { + throw new IllegalArgumentException( + "Invalid start and end labels (end must be greater than start)"); + } + } + return super.visitLocalVariableAnnotation(typeRef, typePath, start, + end, index, desc, visible); + } + @Override public void visitLineNumber(final int line, final Label start) { checkStartCode(); @@ -1202,7 +1347,7 @@ static void checkInternalName(final String name, final int start, checkIdentifier(name, begin, slash, null); begin = slash + 1; } while (slash != max); - } catch (IllegalArgumentException _) { + } catch (IllegalArgumentException unused) { throw new IllegalArgumentException( "Invalid " + msg @@ -1280,7 +1425,7 @@ static int checkDesc(final String desc, final int start, } try { checkInternalName(desc, start + 1, index, null); - } catch (IllegalArgumentException _) { + } catch (IllegalArgumentException unused) { throw new IllegalArgumentException("Invalid descriptor: " + desc); } diff --git a/src/asm/scala/tools/asm/util/CheckSignatureAdapter.java b/src/asm/scala/tools/asm/util/CheckSignatureAdapter.java index e69302b8a6e1..54c9033c90a6 100644 --- a/src/asm/scala/tools/asm/util/CheckSignatureAdapter.java +++ b/src/asm/scala/tools/asm/util/CheckSignatureAdapter.java @@ -113,7 +113,7 @@ public class CheckSignatureAdapter extends SignatureVisitor { * null. */ public CheckSignatureAdapter(final int type, final SignatureVisitor sv) { - this(Opcodes.ASM4, type, sv); + this(Opcodes.ASM5, type, sv); } /** @@ -121,7 +121,7 @@ public CheckSignatureAdapter(final int type, final SignatureVisitor sv) { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. * @param type * the type of signature to be checked. See * {@link #CLASS_SIGNATURE}, {@link #METHOD_SIGNATURE} and diff --git a/src/asm/scala/tools/asm/util/Printer.java b/src/asm/scala/tools/asm/util/Printer.java index 86e0f9e12284..4135672c6b19 100644 --- a/src/asm/scala/tools/asm/util/Printer.java +++ b/src/asm/scala/tools/asm/util/Printer.java @@ -37,6 +37,7 @@ import scala.tools.asm.Handle; import scala.tools.asm.Label; import scala.tools.asm.Opcodes; +import scala.tools.asm.TypePath; /** * An abstract converter from visit events to text. @@ -116,7 +117,7 @@ public abstract class Printer { /** * The ASM API version implemented by this class. The value of this field - * must be one of {@link Opcodes#ASM4}. + * must be one of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. */ protected final int api; @@ -174,6 +175,15 @@ public abstract void visitOuterClass(final String owner, final String name, public abstract Printer visitClassAnnotation(final String desc, final boolean visible); + /** + * Class type annotation. See + * {@link scala.tools.asm.ClassVisitor#visitTypeAnnotation}. + */ + public Printer visitClassTypeAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + throw new RuntimeException("Must be overriden"); + } + /** * Class attribute. See * {@link scala.tools.asm.ClassVisitor#visitAttribute}. @@ -248,6 +258,15 @@ public abstract void visitEnum(final String name, final String desc, public abstract Printer visitFieldAnnotation(final String desc, final boolean visible); + /** + * Field type annotation. See + * {@link scala.tools.asm.FieldVisitor#visitTypeAnnotation}. + */ + public Printer visitFieldTypeAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + throw new RuntimeException("Must be overriden"); + } + /** * Field attribute. See * {@link scala.tools.asm.FieldVisitor#visitAttribute}. @@ -263,6 +282,14 @@ public abstract Printer visitFieldAnnotation(final String desc, // Methods // ------------------------------------------------------------------------ + /** + * Method parameter. See + * {@link scala.tools.asm.MethodVisitor#visitParameter(String, int)}. + */ + public void visitParameter(String name, int access) { + throw new RuntimeException("Must be overriden"); + } + /** * Method default annotation. See * {@link scala.tools.asm.MethodVisitor#visitAnnotationDefault}. @@ -276,6 +303,15 @@ public abstract Printer visitFieldAnnotation(final String desc, public abstract Printer visitMethodAnnotation(final String desc, final boolean visible); + /** + * Method type annotation. See + * {@link scala.tools.asm.MethodVisitor#visitTypeAnnotation}. + */ + public Printer visitMethodTypeAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + throw new RuntimeException("Must be overriden"); + } + /** * Method parameter annotation. See * {@link scala.tools.asm.MethodVisitor#visitParameterAnnotation}. @@ -336,8 +372,33 @@ public abstract void visitFieldInsn(final int opcode, final String owner, * Method instruction. See * {@link scala.tools.asm.MethodVisitor#visitMethodInsn}. */ - public abstract void visitMethodInsn(final int opcode, final String owner, - final String name, final String desc); + @Deprecated + public void visitMethodInsn(final int opcode, final String owner, + final String name, final String desc) { + if (api >= Opcodes.ASM5) { + boolean itf = opcode == Opcodes.INVOKEINTERFACE; + visitMethodInsn(opcode, owner, name, desc, itf); + return; + } + throw new RuntimeException("Must be overriden"); + } + + /** + * Method instruction. See + * {@link scala.tools.asm.MethodVisitor#visitMethodInsn}. + */ + public void visitMethodInsn(final int opcode, final String owner, + final String name, final String desc, final boolean itf) { + if (api < Opcodes.ASM5) { + if (itf != (opcode == Opcodes.INVOKEINTERFACE)) { + throw new IllegalArgumentException( + "INVOKESPECIAL/STATIC on interfaces require ASM 5"); + } + visitMethodInsn(opcode, owner, name, desc); + return; + } + throw new RuntimeException("Must be overriden"); + } /** * Method instruction. See @@ -390,6 +451,15 @@ public abstract void visitLookupSwitchInsn(final Label dflt, public abstract void visitMultiANewArrayInsn(final String desc, final int dims); + /** + * Instruction type annotation. See + * {@link scala.tools.asm.MethodVisitor#visitInsnAnnotation}. + */ + public Printer visitInsnAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + throw new RuntimeException("Must be overriden"); + } + /** * Method exception handler. See * {@link scala.tools.asm.MethodVisitor#visitTryCatchBlock}. @@ -397,6 +467,15 @@ public abstract void visitMultiANewArrayInsn(final String desc, public abstract void visitTryCatchBlock(final Label start, final Label end, final Label handler, final String type); + /** + * Try catch block type annotation. See + * {@link scala.tools.asm.MethodVisitor#visitTryCatchAnnotation}. + */ + public Printer visitTryCatchAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + throw new RuntimeException("Must be overriden"); + } + /** * Method debug info. See * {@link scala.tools.asm.MethodVisitor#visitLocalVariable}. @@ -405,6 +484,16 @@ public abstract void visitLocalVariable(final String name, final String desc, final String signature, final Label start, final Label end, final int index); + /** + * Local variable type annotation. See + * {@link scala.tools.asm.MethodVisitor#visitTryCatchAnnotation}. + */ + public Printer visitLocalVariableAnnotation(final int typeRef, + final TypePath typePath, final Label[] start, final Label[] end, + final int[] index, final String desc, final boolean visible) { + throw new RuntimeException("Must be overriden"); + } + /** * Method debug info. See * {@link scala.tools.asm.MethodVisitor#visitLineNumber}. diff --git a/src/asm/scala/tools/asm/util/Textifier.java b/src/asm/scala/tools/asm/util/Textifier.java index a5c4f6779e44..373e46f5ed5e 100644 --- a/src/asm/scala/tools/asm/util/Textifier.java +++ b/src/asm/scala/tools/asm/util/Textifier.java @@ -40,6 +40,8 @@ import scala.tools.asm.Label; import scala.tools.asm.Opcodes; import scala.tools.asm.Type; +import scala.tools.asm.TypePath; +import scala.tools.asm.TypeReference; import scala.tools.asm.signature.SignatureReader; /** @@ -135,15 +137,26 @@ public class Textifier extends Printer { */ protected Map labelNames; + /** + * Class access flags + */ + private int access; + private int valueNumber = 0; /** * Constructs a new {@link Textifier}. Subclasses must not use this * constructor. Instead, they must use the {@link #Textifier(int)} * version. + * + * @throws IllegalStateException + * If a subclass calls this constructor. */ public Textifier() { - this(Opcodes.ASM4); + this(Opcodes.ASM5); + if (getClass() != Textifier.class) { + throw new IllegalStateException(); + } } /** @@ -151,7 +164,7 @@ public Textifier() { * * @param api * the ASM API version implemented by this visitor. Must be one - * of {@link Opcodes#ASM4}. + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. */ protected Textifier(final int api) { super(api); @@ -208,6 +221,7 @@ public static void main(final String[] args) throws Exception { public void visit(final int version, final int access, final String name, final String signature, final String superName, final String[] interfaces) { + this.access = access; int major = version & 0xFFFF; int minor = version >>> 16; buf.setLength(0); @@ -293,6 +307,13 @@ public Textifier visitClassAnnotation(final String desc, return visitAnnotation(desc, visible); } + @Override + public Printer visitClassTypeAnnotation(int typeRef, TypePath typePath, + String desc, boolean visible) { + text.add("\n"); + return visitTypeAnnotation(typeRef, typePath, desc, visible); + } + @Override public void visitClassAttribute(final Attribute attr) { text.add("\n"); @@ -393,7 +414,7 @@ public Textifier visitMethod(final int access, final String name, } buf.append(tab); - appendAccess(access); + appendAccess(access & ~Opcodes.ACC_VOLATILE); if ((access & Opcodes.ACC_NATIVE) != 0) { buf.append("native "); } @@ -403,6 +424,11 @@ public Textifier visitMethod(final int access, final String name, if ((access & Opcodes.ACC_BRIDGE) != 0) { buf.append("bridge "); } + if ((this.access & Opcodes.ACC_INTERFACE) != 0 + && (access & Opcodes.ACC_ABSTRACT) == 0 + && (access & Opcodes.ACC_STATIC) == 0) { + buf.append("default "); + } buf.append(name); appendDescriptor(METHOD_DESCRIPTOR, desc); @@ -616,6 +642,12 @@ public Textifier visitFieldAnnotation(final String desc, return visitAnnotation(desc, visible); } + @Override + public Printer visitFieldTypeAnnotation(int typeRef, TypePath typePath, + String desc, boolean visible) { + return visitTypeAnnotation(typeRef, typePath, desc, visible); + } + @Override public void visitFieldAttribute(final Attribute attr) { visitAttribute(attr); @@ -629,6 +661,16 @@ public void visitFieldEnd() { // Methods // ------------------------------------------------------------------------ + @Override + public void visitParameter(final String name, final int access) { + buf.setLength(0); + buf.append(tab2).append("// parameter "); + appendAccess(access); + buf.append(' ').append((name == null) ? "" : name) + .append('\n'); + text.add(buf.toString()); + } + @Override public Textifier visitAnnotationDefault() { text.add(tab2 + "default="); @@ -644,6 +686,12 @@ public Textifier visitMethodAnnotation(final String desc, return visitAnnotation(desc, visible); } + @Override + public Printer visitMethodTypeAnnotation(int typeRef, TypePath typePath, + String desc, boolean visible) { + return visitTypeAnnotation(typeRef, typePath, desc, visible); + } + @Override public Textifier visitParameterAnnotation(final int parameter, final String desc, final boolean visible) { @@ -761,9 +809,30 @@ public void visitFieldInsn(final int opcode, final String owner, text.add(buf.toString()); } + @Deprecated @Override public void visitMethodInsn(final int opcode, final String owner, final String name, final String desc) { + if (api >= Opcodes.ASM5) { + super.visitMethodInsn(opcode, owner, name, desc); + return; + } + doVisitMethodInsn(opcode, owner, name, desc, + opcode == Opcodes.INVOKEINTERFACE); + } + + @Override + public void visitMethodInsn(final int opcode, final String owner, + final String name, final String desc, final boolean itf) { + if (api < Opcodes.ASM5) { + super.visitMethodInsn(opcode, owner, name, desc, itf); + return; + } + doVisitMethodInsn(opcode, owner, name, desc, itf); + } + + private void doVisitMethodInsn(final int opcode, final String owner, + final String name, final String desc, final boolean itf) { buf.setLength(0); buf.append(tab2).append(OPCODES[opcode]).append(' '); appendDescriptor(INTERNAL_NAME, owner); @@ -781,26 +850,35 @@ public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, buf.append(name); appendDescriptor(METHOD_DESCRIPTOR, desc); buf.append(" ["); + buf.append('\n'); + buf.append(tab3); appendHandle(bsm); + buf.append('\n'); buf.append(tab3).append("// arguments:"); if (bsmArgs.length == 0) { buf.append(" none"); } else { - buf.append('\n').append(tab3); + buf.append('\n'); for (int i = 0; i < bsmArgs.length; i++) { + buf.append(tab3); Object cst = bsmArgs[i]; if (cst instanceof String) { Printer.appendString(buf, (String) cst); } else if (cst instanceof Type) { - buf.append(((Type) cst).getDescriptor()).append(".class"); + Type type = (Type) cst; + if(type.getSort() == Type.METHOD){ + appendDescriptor(METHOD_DESCRIPTOR, type.getDescriptor()); + } else { + buf.append(type.getDescriptor()).append(".class"); + } } else if (cst instanceof Handle) { appendHandle((Handle) cst); } else { buf.append(cst); } - buf.append(", "); + buf.append(", \n"); } - buf.setLength(buf.length() - 2); + buf.setLength(buf.length() - 3); } buf.append('\n'); buf.append(tab2).append("]\n"); @@ -889,6 +967,12 @@ public void visitMultiANewArrayInsn(final String desc, final int dims) { text.add(buf.toString()); } + @Override + public Printer visitInsnAnnotation(int typeRef, TypePath typePath, + String desc, boolean visible) { + return visitTypeAnnotation(typeRef, typePath, desc, visible); + } + @Override public void visitTryCatchBlock(final Label start, final Label end, final Label handler, final String type) { @@ -905,6 +989,25 @@ public void visitTryCatchBlock(final Label start, final Label end, text.add(buf.toString()); } + @Override + public Printer visitTryCatchAnnotation(int typeRef, TypePath typePath, + String desc, boolean visible) { + buf.setLength(0); + buf.append(tab2).append("TRYCATCHBLOCK @"); + appendDescriptor(FIELD_DESCRIPTOR, desc); + buf.append('('); + text.add(buf.toString()); + Textifier t = createTextifier(); + text.add(t.getText()); + buf.setLength(0); + buf.append(") : "); + appendTypeReference(typeRef); + buf.append(", ").append(typePath); + buf.append(visible ? "\n" : " // invisible\n"); + text.add(buf.toString()); + return t; + } + @Override public void visitLocalVariable(final String name, final String desc, final String signature, final Label start, final Label end, @@ -931,6 +1034,33 @@ public void visitLocalVariable(final String name, final String desc, text.add(buf.toString()); } + @Override + public Printer visitLocalVariableAnnotation(int typeRef, TypePath typePath, + Label[] start, Label[] end, int[] index, String desc, + boolean visible) { + buf.setLength(0); + buf.append(tab2).append("LOCALVARIABLE @"); + appendDescriptor(FIELD_DESCRIPTOR, desc); + buf.append('('); + text.add(buf.toString()); + Textifier t = createTextifier(); + text.add(t.getText()); + buf.setLength(0); + buf.append(") : "); + appendTypeReference(typeRef); + buf.append(", ").append(typePath); + for (int i = 0; i < start.length; ++i) { + buf.append(" [ "); + appendLabel(start[i]); + buf.append(" - "); + appendLabel(end[i]); + buf.append(" - ").append(index[i]).append(" ]"); + } + buf.append(visible ? "\n" : " // invisible\n"); + text.add(buf.toString()); + return t; + } + @Override public void visitLineNumber(final int line, final Label start) { buf.setLength(0); @@ -980,6 +1110,39 @@ public Textifier visitAnnotation(final String desc, final boolean visible) { return t; } + /** + * Prints a disassembled view of the given type annotation. + * + * @param typeRef + * a reference to the annotated type. See {@link TypeReference}. + * @param typePath + * the path to the annotated type argument, wildcard bound, array + * element type, or static inner type within 'typeRef'. May be + * null if the annotation targets 'typeRef' as a whole. + * @param desc + * the class descriptor of the annotation class. + * @param visible + * true if the annotation is visible at runtime. + * @return a visitor to visit the annotation values. + */ + public Textifier visitTypeAnnotation(final int typeRef, + final TypePath typePath, final String desc, final boolean visible) { + buf.setLength(0); + buf.append(tab).append('@'); + appendDescriptor(FIELD_DESCRIPTOR, desc); + buf.append('('); + text.add(buf.toString()); + Textifier t = createTextifier(); + text.add(t.getText()); + buf.setLength(0); + buf.append(") : "); + appendTypeReference(typeRef); + buf.append(", ").append(typePath); + buf.append(visible ? "\n" : " // invisible\n"); + text.add(buf.toString()); + return t; + } + /** * Prints a disassembled view of the given attribute. * @@ -1061,10 +1224,10 @@ protected void appendLabel(final Label l) { * a handle, non null. */ protected void appendHandle(final Handle h) { - buf.append('\n').append(tab3); int tag = h.getTag(); buf.append("// handle kind 0x").append(Integer.toHexString(tag)) .append(" : "); + boolean isMethodHandle = false; switch (tag) { case Opcodes.H_GETFIELD: buf.append("GETFIELD"); @@ -1080,18 +1243,23 @@ protected void appendHandle(final Handle h) { break; case Opcodes.H_INVOKEINTERFACE: buf.append("INVOKEINTERFACE"); + isMethodHandle = true; break; case Opcodes.H_INVOKESPECIAL: buf.append("INVOKESPECIAL"); + isMethodHandle = true; break; case Opcodes.H_INVOKESTATIC: buf.append("INVOKESTATIC"); + isMethodHandle = true; break; case Opcodes.H_INVOKEVIRTUAL: buf.append("INVOKEVIRTUAL"); + isMethodHandle = true; break; case Opcodes.H_NEWINVOKESPECIAL: buf.append("NEWINVOKESPECIAL"); + isMethodHandle = true; break; } buf.append('\n'); @@ -1099,9 +1267,13 @@ protected void appendHandle(final Handle h) { appendDescriptor(INTERNAL_NAME, h.getOwner()); buf.append('.'); buf.append(h.getName()); - buf.append('('); + if(!isMethodHandle){ + buf.append('('); + } appendDescriptor(HANDLE_DESCRIPTOR, h.getDesc()); - buf.append(')').append('\n'); + if(!isMethodHandle){ + buf.append(')'); + } } /** @@ -1145,6 +1317,9 @@ private void appendAccess(final int access) { if ((access & Opcodes.ACC_SYNTHETIC) != 0) { buf.append("synthetic "); } + if ((access & Opcodes.ACC_MANDATED) != 0) { + buf.append("mandated "); + } if ((access & Opcodes.ACC_ENUM) != 0) { buf.append("enum "); } @@ -1156,6 +1331,90 @@ private void appendComa(final int i) { } } + private void appendTypeReference(final int typeRef) { + TypeReference ref = new TypeReference(typeRef); + switch (ref.getSort()) { + case TypeReference.CLASS_TYPE_PARAMETER: + buf.append("CLASS_TYPE_PARAMETER ").append( + ref.getTypeParameterIndex()); + break; + case TypeReference.METHOD_TYPE_PARAMETER: + buf.append("METHOD_TYPE_PARAMETER ").append( + ref.getTypeParameterIndex()); + break; + case TypeReference.CLASS_EXTENDS: + buf.append("CLASS_EXTENDS ").append(ref.getSuperTypeIndex()); + break; + case TypeReference.CLASS_TYPE_PARAMETER_BOUND: + buf.append("CLASS_TYPE_PARAMETER_BOUND ") + .append(ref.getTypeParameterIndex()).append(", ") + .append(ref.getTypeParameterBoundIndex()); + break; + case TypeReference.METHOD_TYPE_PARAMETER_BOUND: + buf.append("METHOD_TYPE_PARAMETER_BOUND ") + .append(ref.getTypeParameterIndex()).append(", ") + .append(ref.getTypeParameterBoundIndex()); + break; + case TypeReference.FIELD: + buf.append("FIELD"); + break; + case TypeReference.METHOD_RETURN: + buf.append("METHOD_RETURN"); + break; + case TypeReference.METHOD_RECEIVER: + buf.append("METHOD_RECEIVER"); + break; + case TypeReference.METHOD_FORMAL_PARAMETER: + buf.append("METHOD_FORMAL_PARAMETER ").append( + ref.getFormalParameterIndex()); + break; + case TypeReference.THROWS: + buf.append("THROWS ").append(ref.getExceptionIndex()); + break; + case TypeReference.LOCAL_VARIABLE: + buf.append("LOCAL_VARIABLE"); + break; + case TypeReference.RESOURCE_VARIABLE: + buf.append("RESOURCE_VARIABLE"); + break; + case TypeReference.EXCEPTION_PARAMETER: + buf.append("EXCEPTION_PARAMETER ").append( + ref.getTryCatchBlockIndex()); + break; + case TypeReference.INSTANCEOF: + buf.append("INSTANCEOF"); + break; + case TypeReference.NEW: + buf.append("NEW"); + break; + case TypeReference.CONSTRUCTOR_REFERENCE: + buf.append("CONSTRUCTOR_REFERENCE"); + break; + case TypeReference.METHOD_REFERENCE: + buf.append("METHOD_REFERENCE"); + break; + case TypeReference.CAST: + buf.append("CAST ").append(ref.getTypeArgumentIndex()); + break; + case TypeReference.CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT: + buf.append("CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT ").append( + ref.getTypeArgumentIndex()); + break; + case TypeReference.METHOD_INVOCATION_TYPE_ARGUMENT: + buf.append("METHOD_INVOCATION_TYPE_ARGUMENT ").append( + ref.getTypeArgumentIndex()); + break; + case TypeReference.CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT: + buf.append("CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT ").append( + ref.getTypeArgumentIndex()); + break; + case TypeReference.METHOD_REFERENCE_TYPE_ARGUMENT: + buf.append("METHOD_REFERENCE_TYPE_ARGUMENT ").append( + ref.getTypeArgumentIndex()); + break; + } + } + private void appendFrameTypes(final int n, final Object[] o) { for (int i = 0; i < n; ++i) { if (i > 0) { diff --git a/src/asm/scala/tools/asm/util/TraceAnnotationVisitor.java b/src/asm/scala/tools/asm/util/TraceAnnotationVisitor.java index 33e7cf0b267b..7a9dbfef06d4 100644 --- a/src/asm/scala/tools/asm/util/TraceAnnotationVisitor.java +++ b/src/asm/scala/tools/asm/util/TraceAnnotationVisitor.java @@ -47,7 +47,7 @@ public TraceAnnotationVisitor(final Printer p) { } public TraceAnnotationVisitor(final AnnotationVisitor av, final Printer p) { - super(Opcodes.ASM4, av); + super(Opcodes.ASM5, av); this.p = p; } diff --git a/src/asm/scala/tools/asm/util/TraceClassVisitor.java b/src/asm/scala/tools/asm/util/TraceClassVisitor.java index ff7a017482e5..842d2866728a 100644 --- a/src/asm/scala/tools/asm/util/TraceClassVisitor.java +++ b/src/asm/scala/tools/asm/util/TraceClassVisitor.java @@ -37,6 +37,7 @@ import scala.tools.asm.FieldVisitor; import scala.tools.asm.MethodVisitor; import scala.tools.asm.Opcodes; +import scala.tools.asm.TypePath; /** * A {@link ClassVisitor} that prints the classes it visits with a @@ -130,7 +131,7 @@ public TraceClassVisitor(final ClassVisitor cv, final PrintWriter pw) { */ public TraceClassVisitor(final ClassVisitor cv, final Printer p, final PrintWriter pw) { - super(Opcodes.ASM4, cv); + super(Opcodes.ASM5, cv); this.pw = pw; this.p = p; } @@ -165,6 +166,16 @@ public AnnotationVisitor visitAnnotation(final String desc, return new TraceAnnotationVisitor(av, p); } + @Override + public AnnotationVisitor visitTypeAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + Printer p = this.p.visitClassTypeAnnotation(typeRef, typePath, desc, + visible); + AnnotationVisitor av = cv == null ? null : cv.visitTypeAnnotation( + typeRef, typePath, desc, visible); + return new TraceAnnotationVisitor(av, p); + } + @Override public void visitAttribute(final Attribute attr) { p.visitClassAttribute(attr); diff --git a/src/asm/scala/tools/asm/util/TraceFieldVisitor.java b/src/asm/scala/tools/asm/util/TraceFieldVisitor.java index 9547a70008ed..1d0743a42430 100644 --- a/src/asm/scala/tools/asm/util/TraceFieldVisitor.java +++ b/src/asm/scala/tools/asm/util/TraceFieldVisitor.java @@ -33,6 +33,7 @@ import scala.tools.asm.Attribute; import scala.tools.asm.FieldVisitor; import scala.tools.asm.Opcodes; +import scala.tools.asm.TypePath; /** * A {@link FieldVisitor} that prints the fields it visits with a @@ -49,7 +50,7 @@ public TraceFieldVisitor(final Printer p) { } public TraceFieldVisitor(final FieldVisitor fv, final Printer p) { - super(Opcodes.ASM4, fv); + super(Opcodes.ASM5, fv); this.p = p; } @@ -62,6 +63,16 @@ public AnnotationVisitor visitAnnotation(final String desc, return new TraceAnnotationVisitor(av, p); } + @Override + public AnnotationVisitor visitTypeAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + Printer p = this.p.visitFieldTypeAnnotation(typeRef, typePath, desc, + visible); + AnnotationVisitor av = fv == null ? null : fv.visitTypeAnnotation( + typeRef, typePath, desc, visible); + return new TraceAnnotationVisitor(av, p); + } + @Override public void visitAttribute(final Attribute attr) { p.visitFieldAttribute(attr); diff --git a/src/asm/scala/tools/asm/util/TraceMethodVisitor.java b/src/asm/scala/tools/asm/util/TraceMethodVisitor.java index 9034567c8f64..db5f05100371 100644 --- a/src/asm/scala/tools/asm/util/TraceMethodVisitor.java +++ b/src/asm/scala/tools/asm/util/TraceMethodVisitor.java @@ -35,6 +35,7 @@ import scala.tools.asm.Label; import scala.tools.asm.MethodVisitor; import scala.tools.asm.Opcodes; +import scala.tools.asm.TypePath; /** * A {@link MethodVisitor} that prints the methods it visits with a @@ -51,10 +52,16 @@ public TraceMethodVisitor(final Printer p) { } public TraceMethodVisitor(final MethodVisitor mv, final Printer p) { - super(Opcodes.ASM4, mv); + super(Opcodes.ASM5, mv); this.p = p; } + @Override + public void visitParameter(String name, int access) { + p.visitParameter(name, access); + super.visitParameter(name, access); + } + @Override public AnnotationVisitor visitAnnotation(final String desc, final boolean visible) { @@ -64,6 +71,16 @@ public AnnotationVisitor visitAnnotation(final String desc, return new TraceAnnotationVisitor(av, p); } + @Override + public AnnotationVisitor visitTypeAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + Printer p = this.p.visitMethodTypeAnnotation(typeRef, typePath, desc, + visible); + AnnotationVisitor av = mv == null ? null : mv.visitTypeAnnotation( + typeRef, typePath, desc, visible); + return new TraceAnnotationVisitor(av, p); + } + @Override public void visitAttribute(final Attribute attr) { p.visitMethodAttribute(attr); @@ -130,11 +147,31 @@ public void visitFieldInsn(final int opcode, final String owner, super.visitFieldInsn(opcode, owner, name, desc); } + @Deprecated @Override - public void visitMethodInsn(final int opcode, final String owner, - final String name, final String desc) { + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + if (api >= Opcodes.ASM5) { + super.visitMethodInsn(opcode, owner, name, desc); + return; + } p.visitMethodInsn(opcode, owner, name, desc); - super.visitMethodInsn(opcode, owner, name, desc); + if (mv != null) { + mv.visitMethodInsn(opcode, owner, name, desc); + } + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc, boolean itf) { + if (api < Opcodes.ASM5) { + super.visitMethodInsn(opcode, owner, name, desc, itf); + return; + } + p.visitMethodInsn(opcode, owner, name, desc, itf); + if (mv != null) { + mv.visitMethodInsn(opcode, owner, name, desc, itf); + } } @Override @@ -188,6 +225,16 @@ public void visitMultiANewArrayInsn(final String desc, final int dims) { super.visitMultiANewArrayInsn(desc, dims); } + @Override + public AnnotationVisitor visitInsnAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + Printer p = this.p + .visitInsnAnnotation(typeRef, typePath, desc, visible); + AnnotationVisitor av = mv == null ? null : mv.visitInsnAnnotation( + typeRef, typePath, desc, visible); + return new TraceAnnotationVisitor(av, p); + } + @Override public void visitTryCatchBlock(final Label start, final Label end, final Label handler, final String type) { @@ -195,6 +242,16 @@ public void visitTryCatchBlock(final Label start, final Label end, super.visitTryCatchBlock(start, end, handler, type); } + @Override + public AnnotationVisitor visitTryCatchAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + Printer p = this.p.visitTryCatchAnnotation(typeRef, typePath, desc, + visible); + AnnotationVisitor av = mv == null ? null : mv.visitTryCatchAnnotation( + typeRef, typePath, desc, visible); + return new TraceAnnotationVisitor(av, p); + } + @Override public void visitLocalVariable(final String name, final String desc, final String signature, final Label start, final Label end, @@ -203,6 +260,18 @@ public void visitLocalVariable(final String name, final String desc, super.visitLocalVariable(name, desc, signature, start, end, index); } + @Override + public AnnotationVisitor visitLocalVariableAnnotation(int typeRef, + TypePath typePath, Label[] start, Label[] end, int[] index, + String desc, boolean visible) { + Printer p = this.p.visitLocalVariableAnnotation(typeRef, typePath, + start, end, index, desc, visible); + AnnotationVisitor av = mv == null ? null : mv + .visitLocalVariableAnnotation(typeRef, typePath, start, end, + index, desc, visible); + return new TraceAnnotationVisitor(av, p); + } + @Override public void visitLineNumber(final int line, final Label start) { p.visitLineNumber(line, start); diff --git a/src/asm/scala/tools/asm/util/TraceSignatureVisitor.java b/src/asm/scala/tools/asm/util/TraceSignatureVisitor.java index 1e23c7ef1a34..f99ec2b0c242 100644 --- a/src/asm/scala/tools/asm/util/TraceSignatureVisitor.java +++ b/src/asm/scala/tools/asm/util/TraceSignatureVisitor.java @@ -75,13 +75,13 @@ public final class TraceSignatureVisitor extends SignatureVisitor { private String separator = ""; public TraceSignatureVisitor(final int access) { - super(Opcodes.ASM4); + super(Opcodes.ASM5); isInterface = (access & Opcodes.ACC_INTERFACE) != 0; this.declaration = new StringBuffer(); } private TraceSignatureVisitor(final StringBuffer buf) { - super(Opcodes.ASM4); + super(Opcodes.ASM5); this.declaration = buf; } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala index 1ede91428806..3fdb38ce0e0e 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala @@ -824,7 +824,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { index += jparamType.getSize } - mirrorMethod.visitMethodInsn(asm.Opcodes.INVOKEVIRTUAL, moduleName, mirrorMethodName, asmMethodType(m).getDescriptor) + mirrorMethod.visitMethodInsn(asm.Opcodes.INVOKEVIRTUAL, moduleName, mirrorMethodName, asmMethodType(m).getDescriptor, false) mirrorMethod.visitInsn(jReturnType.getOpcode(asm.Opcodes.IRETURN)) mirrorMethod.visitMaxs(0, 0) // just to follow protocol, dummy arguments @@ -1122,7 +1122,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { // invoke the superclass constructor, which will do the // necessary java reflection and create Method objects. - constructor.visitMethodInsn(asm.Opcodes.INVOKESPECIAL, "scala/beans/ScalaBeanInfo", INSTANCE_CONSTRUCTOR_NAME, conJType.getDescriptor) + constructor.visitMethodInsn(asm.Opcodes.INVOKESPECIAL, "scala/beans/ScalaBeanInfo", INSTANCE_CONSTRUCTOR_NAME, conJType.getDescriptor, false) constructor.visitInsn(asm.Opcodes.RETURN) constructor.visitMaxs(0, 0) // just to follow protocol, dummy arguments @@ -1187,7 +1187,8 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { asm.Opcodes.INVOKEVIRTUAL, moduleName, "CREATOR", - bt.getDescriptor + bt.getDescriptor, + false ) // PUTSTATIC `thisName`.CREATOR; diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala index c3492b79a9e6..f9f6e7c3ff09 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala @@ -409,19 +409,19 @@ abstract class BCodeIdiomatic extends BCodeGlue { // can-multi-thread final def invokespecial(owner: String, name: String, desc: String) { - jmethod.visitMethodInsn(Opcodes.INVOKESPECIAL, owner, name, desc) + jmethod.visitMethodInsn(Opcodes.INVOKESPECIAL, owner, name, desc, false) } // can-multi-thread final def invokestatic(owner: String, name: String, desc: String) { - jmethod.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc) + jmethod.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc, false) } // can-multi-thread final def invokeinterface(owner: String, name: String, desc: String) { - jmethod.visitMethodInsn(Opcodes.INVOKEINTERFACE, owner, name, desc) + jmethod.visitMethodInsn(Opcodes.INVOKEINTERFACE, owner, name, desc, true) } // can-multi-thread final def invokevirtual(owner: String, name: String, desc: String) { - jmethod.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc) + jmethod.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc, false) } // can-multi-thread diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala index ee9be5b11c69..a76fa4d7ba0d 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala @@ -234,7 +234,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { if (isCZStaticModule) { clinit.visitTypeInsn(asm.Opcodes.NEW, thisName) clinit.visitMethodInsn(asm.Opcodes.INVOKESPECIAL, - thisName, INSTANCE_CONSTRUCTOR_NAME, "()V") + thisName, INSTANCE_CONSTRUCTOR_NAME, "()V", false) } if (isCZParcelable) { legacyAddCreatorCode(clinit, cnode, thisName) } clinit.visitInsn(asm.Opcodes.RETURN) @@ -686,7 +686,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { val jname = callee.javaSimpleName.toString val jowner = internalName(callee.owner) val jtype = asmMethodType(callee).getDescriptor - insnModB = new asm.tree.MethodInsnNode(asm.Opcodes.INVOKESPECIAL, jowner, jname, jtype) + insnModB = new asm.tree.MethodInsnNode(asm.Opcodes.INVOKESPECIAL, jowner, jname, jtype, false) } var insnParcA: asm.tree.AbstractInsnNode = null @@ -707,7 +707,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { val jowner = internalName(callee.owner) val jname = callee.javaSimpleName.toString val jtype = asmMethodType(callee).getDescriptor - insnParcA = new asm.tree.MethodInsnNode(asm.Opcodes.INVOKESTATIC, jowner, jname, jtype) + insnParcA = new asm.tree.MethodInsnNode(asm.Opcodes.INVOKESTATIC, jowner, jname, jtype, false) // PUTSTATIC `thisName`.CREATOR; insnParcB = new asm.tree.FieldInsnNode(asm.Opcodes.PUTSTATIC, thisName, "CREATOR", andrFieldDescr) } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala index b7f9b30e199e..13a5c6413d76 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala @@ -975,7 +975,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { index += jparamType.getSize() } - mirrorMethod.visitMethodInsn(asm.Opcodes.INVOKEVIRTUAL, moduleName, mirrorMethodName, javaType(m).getDescriptor) + mirrorMethod.visitMethodInsn(asm.Opcodes.INVOKEVIRTUAL, moduleName, mirrorMethodName, javaType(m).getDescriptor, false) mirrorMethod.visitInsn(jReturnType.getOpcode(asm.Opcodes.IRETURN)) mirrorMethod.visitMaxs(0, 0) // just to follow protocol, dummy arguments @@ -1061,7 +1061,8 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { asm.Opcodes.INVOKEVIRTUAL, moduleName, androidFieldName.toString, - asm.Type.getMethodDescriptor(creatorType, Array.empty[asm.Type]: _*) + asm.Type.getMethodDescriptor(creatorType, Array.empty[asm.Type]: _*), + false ) // PUTSTATIC `thisName`.CREATOR; @@ -1521,7 +1522,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { if (isStaticModule(clasz.symbol)) { clinit.visitTypeInsn(asm.Opcodes.NEW, thisName) clinit.visitMethodInsn(asm.Opcodes.INVOKESPECIAL, - thisName, INSTANCE_CONSTRUCTOR_NAME, mdesc_arglessvoid) + thisName, INSTANCE_CONSTRUCTOR_NAME, mdesc_arglessvoid, false) } if (isParcelableClass) { legacyAddCreatorCode(clinit) } @@ -1665,16 +1666,16 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { def rem(tk: TypeKind) { emitPrimitive(remOpcodes, tk) } def invokespecial(owner: String, name: String, desc: String) { - jmethod.visitMethodInsn(Opcodes.INVOKESPECIAL, owner, name, desc) + jmethod.visitMethodInsn(Opcodes.INVOKESPECIAL, owner, name, desc, false) } def invokestatic(owner: String, name: String, desc: String) { - jmethod.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc) + jmethod.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc, false) } def invokeinterface(owner: String, name: String, desc: String) { - jmethod.visitMethodInsn(Opcodes.INVOKEINTERFACE, owner, name, desc) + jmethod.visitMethodInsn(Opcodes.INVOKEINTERFACE, owner, name, desc, true) } def invokevirtual(owner: String, name: String, desc: String) { - jmethod.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc) + jmethod.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc, false) } def goTo(label: asm.Label) { jmethod.visitJumpInsn(Opcodes.GOTO, label) } @@ -2924,7 +2925,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { // invoke the superclass constructor, which will do the // necessary java reflection and create Method objects. - constructor.visitMethodInsn(asm.Opcodes.INVOKESPECIAL, "scala/beans/ScalaBeanInfo", INSTANCE_CONSTRUCTOR_NAME, conJType.getDescriptor) + constructor.visitMethodInsn(asm.Opcodes.INVOKESPECIAL, "scala/beans/ScalaBeanInfo", INSTANCE_CONSTRUCTOR_NAME, conJType.getDescriptor, false) constructor.visitInsn(asm.Opcodes.RETURN) constructor.visitMaxs(0, 0) // just to follow protocol, dummy arguments diff --git a/src/partest-javaagent/scala/tools/partest/javaagent/ProfilerVisitor.java b/src/partest-javaagent/scala/tools/partest/javaagent/ProfilerVisitor.java index b1b100fbb06e..d97756c17142 100644 --- a/src/partest-javaagent/scala/tools/partest/javaagent/ProfilerVisitor.java +++ b/src/partest-javaagent/scala/tools/partest/javaagent/ProfilerVisitor.java @@ -50,7 +50,7 @@ public MethodVisitor visitMethod(int access, String name, String desc, String si mv.visitLdcInsn(name); mv.visitLdcInsn(desc); mv.visitMethodInsn(INVOKESTATIC, profilerClass, "methodCalled", - "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"); + "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V", false); } } return mv; diff --git a/test/files/run/classfile-format-51.scala b/test/files/run/classfile-format-51.scala index f92382d89b9f..24b1ee8397eb 100644 --- a/test/files/run/classfile-format-51.scala +++ b/test/files/run/classfile-format-51.scala @@ -32,7 +32,7 @@ object Test extends DirectTest { val constructor = cw.visitMethod(ACC_PUBLIC, "", "()V", null, null) constructor.visitCode() constructor.visitVarInsn(ALOAD, 0) - constructor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "", "()V") + constructor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "", "()V", false) constructor.visitInsn(RETURN) constructor.visitMaxs(1, 1) constructor.visitEnd() @@ -47,19 +47,19 @@ object Test extends DirectTest { val bootstrap = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, bootstrapMethodName, bootStrapMethodType, null, null) bootstrap.visitCode() // val lookup = MethodHandles.lookup(); - bootstrap.visitMethodInsn(INVOKESTATIC, "java/lang/invoke/MethodHandles", "lookup", "()Ljava/lang/invoke/MethodHandles$Lookup;") + bootstrap.visitMethodInsn(INVOKESTATIC, "java/lang/invoke/MethodHandles", "lookup", "()Ljava/lang/invoke/MethodHandles$Lookup;", false) bootstrap.visitVarInsn(ASTORE, 3) // lookup // val clazz = lookup.lookupClass(); bootstrap.visitVarInsn(ALOAD, 3) // lookup - bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandles$Lookup", "lookupClass", "()Ljava/lang/Class;") + bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandles$Lookup", "lookupClass", "()Ljava/lang/Class;", false) bootstrap.visitVarInsn(ASTORE, 4) // clazz // val methodType = MethodType.fromMethodDescriptorString("()Ljava/lang/String, clazz.getClassLoader()") bootstrap.visitLdcInsn("()Ljava/lang/String;") bootstrap.visitVarInsn(ALOAD, 4) // CLAZZ - bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Class", "getClassLoader", "()Ljava/lang/ClassLoader;") - bootstrap.visitMethodInsn(INVOKESTATIC, "java/lang/invoke/MethodType", "fromMethodDescriptorString", "(Ljava/lang/String;Ljava/lang/ClassLoader;)Ljava/lang/invoke/MethodType;") + bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Class", "getClassLoader", "()Ljava/lang/ClassLoader;", false) + bootstrap.visitMethodInsn(INVOKESTATIC, "java/lang/invoke/MethodType", "fromMethodDescriptorString", "(Ljava/lang/String;Ljava/lang/ClassLoader;)Ljava/lang/invoke/MethodType;", false) bootstrap.visitVarInsn(ASTORE, 5) // methodType // val methodHandle = lookup.findStatic(thisClass, "target", methodType) @@ -67,14 +67,14 @@ object Test extends DirectTest { bootstrap.visitVarInsn(ALOAD, 4) // clazz bootstrap.visitLdcInsn("target") bootstrap.visitVarInsn(ALOAD, 5) // methodType - bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandles$Lookup", "findStatic", "(Ljava/lang/Class;Ljava/lang/String;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/MethodHandle;") + bootstrap.visitMethodInsn(INVOKEVIRTUAL, "java/lang/invoke/MethodHandles$Lookup", "findStatic", "(Ljava/lang/Class;Ljava/lang/String;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/MethodHandle;", false) bootstrap.visitVarInsn(ASTORE, 6) // methodHandle // new ConstantCallSite(methodHandle) bootstrap.visitTypeInsn(NEW, "java/lang/invoke/ConstantCallSite") bootstrap.visitInsn(DUP) bootstrap.visitVarInsn(ALOAD, 6) // methodHandle - bootstrap.visitMethodInsn(INVOKESPECIAL, "java/lang/invoke/ConstantCallSite", "", "(Ljava/lang/invoke/MethodHandle;)V") + bootstrap.visitMethodInsn(INVOKESPECIAL, "java/lang/invoke/ConstantCallSite", "", "(Ljava/lang/invoke/MethodHandle;)V", false) bootstrap.visitInsn(ARETURN) bootstrap.visitMaxs(4,7) bootstrap.visitEnd() diff --git a/test/files/run/large_class.check b/test/files/run/large_class.check new file mode 100644 index 000000000000..0585c267ac43 --- /dev/null +++ b/test/files/run/large_class.check @@ -0,0 +1,3 @@ +newSource1.scala:1: error: Could not write class BigEnoughToFail because it exceeds JVM code size limits. Class file too large! +class BigEnoughToFail { + ^ diff --git a/test/files/run/large_class.scala b/test/files/run/large_class.scala new file mode 100644 index 000000000000..aa486ef8f7ed --- /dev/null +++ b/test/files/run/large_class.scala @@ -0,0 +1,27 @@ +import scala.tools.partest._ +import java.io.{Console => _, _} + +// a cold run of partest takes about 15s for this test on my laptop +object Test extends DirectTest { + override def extraSettings: String = "-usejavacp -d " + testOutput.path + + def s(n: Int) = "\""+n+"\"" + + override def code + = s""" + |class BigEnoughToFail { + | def m(a: String, b: String, c: String, d: String, e: String, f: String) = null + | ${(1 to 5500) map (n => "def f"+n+" = m("+ s(n+10000)+","+ + s(n+20000)+","+ + s(n+30000)+","+ + s(n+40000)+","+ + s(n+50000)+","+ + s(n+60000)+")") mkString ";"} + |}""".stripMargin.trim + + override def show(): Unit = { + Console.withErr(System.out) { + compile() + } + } +} From 75c411c85115d7907f8e2cbe0fb16bd5618ba8a5 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Wed, 21 May 2014 09:40:33 +0200 Subject: [PATCH 275/826] SI-8607 Fix erasure for value class inheriting from private class The fix for SI-4283 added a pre-emptive cast of the qualifier of a selection `qual.a` to avoid later casting to the owner of `a` if that owner might be inaccessible at the call site. This fixed a `LinkageError`. In the enclosed test, this cast led to the following diff in the tree shapes (with respect to a version with a public base class). [erasure] - new p1.C.(c.$asInstanceOf[scala.this.Int]()).a(); + new p1.C.(new p1.C.(c.$asInstanceOf[scala.this.Int]()).$asInstanceOf[ErasedValueType( class C, scala.this.Int)]().$asInstanceOf[scala.this.Int]()).a(); [posterasure] - new p1.C.(c).a(); + new p1.C.(new p1.C.(c).$asInstanceOf[scala.this.Int]().$asInstanceOf[scala.this.Int]()) .a(); () What we really wanted to end up with is: new p1.C.(c).$asInstanceOf[C]().a(); The stray cast leads to the crash: error: should have been unboxed by erasure: new p1.C.(c).$asInstanceOf[scala.this.Int]() Rather than trying to fix this in erasure/posterasure, this commit instead relies on the fact the owner of `a` cannot be Java defined if `qual`s type is a derived value class. This follows from the restrictions we place on value classes. With this knowledge, we elide the cast altogether in this case. --- .../scala/tools/nsc/transform/Erasure.scala | 8 ++++- test/files/run/t8607.scala | 36 +++++++++++++++++++ 2 files changed, 43 insertions(+), 1 deletion(-) create mode 100644 test/files/run/t8607.scala diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala index e03603539781..e31cb02033aa 100644 --- a/src/compiler/scala/tools/nsc/transform/Erasure.scala +++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala @@ -1066,7 +1066,13 @@ abstract class Erasure extends AddInterfaces if (isAccessible(qualSym) && !qualSym.isPackageClass && !qualSym.isPackageObjectClass) { // insert cast to prevent illegal access error (see #4283) // util.trace("insert erasure cast ") (*/ - treeCopy.Select(tree, gen.mkAttributedCast(qual, qual.tpe.widen), name) //) + if (qualSym.isDerivedValueClass) { + assert(!owner.isJavaDefined, owner) + // Safe, as derived value can't extend Java classes that would be JVM inaccessible + devWarning("SI-8607 Not casting qualifier ${qual} to its widened type as it is a derived value class and this cast will trip up the rest of erasure/post erasure.") + tree + } else + treeCopy.Select(tree, gen.mkAttributedCast(qual, qual.tpe.widen), name) //) } else tree } } else tree diff --git a/test/files/run/t8607.scala b/test/files/run/t8607.scala new file mode 100644 index 000000000000..1b8ef9bbd023 --- /dev/null +++ b/test/files/run/t8607.scala @@ -0,0 +1,36 @@ +package p1 { + private[p1] trait B extends Any { + def a: Any = "" + } + + class C(val value: Int) extends AnyVal with B { + // def b = "" + } +} + +object Test { + def main(args: Array[String]) { + val c = new p1.C(42) + c.a + /* + new p1.C.( + c.$asInstanceOf[scala.this.Int]() + ).a(); + + + new p1.C.( + new p1.C.( + c.$asInstanceOf[scala.this.Int]() + ).$asInstanceOf[ErasedValueType(class C, scala.this.Int)]() + .$asInstanceOf[scala.this.Int]() + ).a(); + + new p1.C.( + new p1.C.(c) + .$asInstanceOf[scala.this.Int]() + .$asInstanceOf[scala.this.Int]() + ).a(); + + */ + } +} From 93bcff07b445e6c6c59b378914d5276af73404a4 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Wed, 21 May 2014 09:58:34 +0200 Subject: [PATCH 276/826] SI-8607 Generalize previous change to preErase In the previous commit, we avoided an awkward chain of casts by exploiting the knowledge that Scala defined classes will by JVM accessible, and as such immune to `LinkageError`s when used as the target of a cast. This commit generalized this to the entire fix for SI-4283, rather than just for derived value classes. --- .../scala/tools/nsc/transform/Erasure.scala | 20 ++++++------------- test/files/run/analyzerPlugins.check | 13 +++++------- 2 files changed, 11 insertions(+), 22 deletions(-) diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala index e31cb02033aa..2f2142027fe2 100644 --- a/src/compiler/scala/tools/nsc/transform/Erasure.scala +++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala @@ -1050,29 +1050,21 @@ abstract class Erasure extends AddInterfaces } } - def isAccessible(sym: Symbol) = localTyper.context.isAccessible(sym, sym.owner.thisType) - if (!isAccessible(owner) && qual.tpe != null) { + def isJvmAccessible(sym: Symbol) = (sym.isClass && !sym.isJavaDefined) || localTyper.context.isAccessible(sym, sym.owner.thisType) + if (!isJvmAccessible(owner) && qual.tpe != null) { qual match { case Super(_, _) => - // Insert a cast here at your peril -- see SI-5162. Bail out if the target method is defined in - // Java, otherwise, we'd get an IllegalAccessError at runtime. If the target method is defined in - // Scala, however, we should have access. - if (owner.isJavaDefined) unit.error(tree.pos, s"Unable to access ${tree.symbol.fullLocationString} with a super reference.") + // Insert a cast here at your peril -- see SI-5162. + unit.error(tree.pos, s"Unable to access ${tree.symbol.fullLocationString} with a super reference.") tree case _ => // Todo: Figure out how qual.tpe could be null in the check above (it does appear in build where SwingWorker.this // has a null type). val qualSym = qual.tpe.widen.typeSymbol - if (isAccessible(qualSym) && !qualSym.isPackageClass && !qualSym.isPackageObjectClass) { + if (isJvmAccessible(qualSym) && !qualSym.isPackageClass && !qualSym.isPackageObjectClass) { // insert cast to prevent illegal access error (see #4283) // util.trace("insert erasure cast ") (*/ - if (qualSym.isDerivedValueClass) { - assert(!owner.isJavaDefined, owner) - // Safe, as derived value can't extend Java classes that would be JVM inaccessible - devWarning("SI-8607 Not casting qualifier ${qual} to its widened type as it is a derived value class and this cast will trip up the rest of erasure/post erasure.") - tree - } else - treeCopy.Select(tree, gen.mkAttributedCast(qual, qual.tpe.widen), name) //) + treeCopy.Select(tree, gen.mkAttributedCast(qual, qual.tpe.widen), name) //) } else tree } } else tree diff --git a/test/files/run/analyzerPlugins.check b/test/files/run/analyzerPlugins.check index e3ab554d4c99..9803465ddc23 100644 --- a/test/files/run/analyzerPlugins.check +++ b/test/files/run/analyzerPlugins.check @@ -19,7 +19,7 @@ canAdaptAnnotations(Trees$Typed, Any) [1] canAdaptAnnotations(Trees$Typed, Int) [1] lub(List(Int @testAnn, Int)) [1] pluginsPt(?, Trees$Annotated) [7] -pluginsPt(?, Trees$Apply) [9] +pluginsPt(?, Trees$Apply) [8] pluginsPt(?, Trees$ApplyImplicitView) [2] pluginsPt(?, Trees$Assign) [7] pluginsPt(?, Trees$Block) [4] @@ -31,13 +31,13 @@ pluginsPt(?, Trees$Literal) [16] pluginsPt(?, Trees$New) [5] pluginsPt(?, Trees$PackageDef) [1] pluginsPt(?, Trees$Return) [1] -pluginsPt(?, Trees$Select) [48] +pluginsPt(?, Trees$Select) [47] pluginsPt(?, Trees$Super) [2] pluginsPt(?, Trees$This) [20] -pluginsPt(?, Trees$TypeApply) [4] +pluginsPt(?, Trees$TypeApply) [3] pluginsPt(?, Trees$TypeBoundsTree) [2] pluginsPt(?, Trees$TypeDef) [1] -pluginsPt(?, Trees$TypeTree) [39] +pluginsPt(?, Trees$TypeTree) [38] pluginsPt(?, Trees$Typed) [1] pluginsPt(?, Trees$ValDef) [21] pluginsPt(Any, Trees$Literal) [2] @@ -98,7 +98,6 @@ pluginsTyped(()String, Trees$Ident) [1] pluginsTyped(()String, Trees$TypeApply) [1] pluginsTyped(()scala.annotation.Annotation, Trees$Select) [1] pluginsTyped(()testAnn, Trees$Select) [10] -pluginsTyped(()type, Trees$TypeApply) [1] pluginsTyped((str: String)A (param: Double)A, Trees$Select) [1] pluginsTyped((x$1: Any)Boolean (x: Double)Boolean (x: Float)Boolean (x: Long)Boolean (x: Int)Boolean (x: Char)Boolean (x: Short)Boolean (x: Byte)Boolean, Trees$Select) [1] pluginsTyped((x$1: Int)Unit, Trees$Select) [1] @@ -173,7 +172,7 @@ pluginsTyped(Unit, Trees$Literal) [5] pluginsTyped(Unit, Trees$TypeTree) [1] pluginsTyped([A](xs: A*)List[A], Trees$Select) [1] pluginsTyped([T <: Int]=> Int, Trees$Select) [1] -pluginsTyped([T0]()T0, Trees$Select) [2] +pluginsTyped([T0]()T0, Trees$Select) [1] pluginsTyped([T](xs: Array[T])scala.collection.mutable.WrappedArray[T], Trees$Select) [1] pluginsTyped(annotation.type, Trees$Select) [4] pluginsTyped(math.type, Trees$Select) [9] @@ -190,7 +189,5 @@ pluginsTyped(testAnn, Trees$New) [5] pluginsTyped(testAnn, Trees$This) [1] pluginsTyped(testAnn, Trees$TypeTree) [2] pluginsTyped(testAnn.super.type, Trees$Super) [1] -pluginsTyped(type, Trees$Apply) [1] pluginsTyped(type, Trees$Select) [1] -pluginsTyped(type, Trees$TypeTree) [1] pluginsTypedReturn(return f, String) [1] From 56ed4fc79580d4a0b7a264a436db3010543a9211 Mon Sep 17 00:00:00 2001 From: Denys Shabalin Date: Wed, 21 May 2014 16:33:58 +0200 Subject: [PATCH 277/826] SI-8609 Fix flattening of definitions and imports in quasiquotes Quasiquotes allow to unquote trees with ..$ with block flattening semantics to simplify composition: val onetwo = q"1; 2" val onetwothree = q"..$onetwo; 3" // same as q"1; 2; 3" If there is no block it will be equivalent to $ unquoting: val one = q"1" val onetwo = q"..$one; 2" // same as q"1; 2" But the inconsistency here is that currently only terms support this single-element semantics. This commit extends this functionality to also support definitions and imports. So that following code works: val q1 = q"val x = 1" val q2 = q"..$q1; val y = 2" // same as q"val x = 1; val y = 2" --- .../scala/reflect/internal/ReificationSupport.scala | 2 ++ .../quasiquotes/TermConstructionProps.scala | 12 ++++++++++++ 2 files changed, 14 insertions(+) diff --git a/src/reflect/scala/reflect/internal/ReificationSupport.scala b/src/reflect/scala/reflect/internal/ReificationSupport.scala index ad8a2594dde9..2caa30d27e76 100644 --- a/src/reflect/scala/reflect/internal/ReificationSupport.scala +++ b/src/reflect/scala/reflect/internal/ReificationSupport.scala @@ -97,6 +97,8 @@ trait ReificationSupport { self: SymbolTable => def toStats(tree: Tree): List[Tree] = tree match { case EmptyTree => Nil case SyntacticBlock(stats) => stats + case defn if defn.isDef => defn :: Nil + case imp: Import => imp :: Nil case _ => throw new IllegalArgumentException(s"can't flatten $tree") } diff --git a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala index 45392de58285..409f07037e54 100644 --- a/test/files/scalacheck/quasiquotes/TermConstructionProps.scala +++ b/test/files/scalacheck/quasiquotes/TermConstructionProps.scala @@ -310,4 +310,16 @@ object TermConstructionProps extends QuasiquoteProperties("term construction") { val cases = List(cq"a => b", cq"c => d") assertEqAst(q"{ case ..$cases }", "{ case a => b case c => d }") } + + property("SI-8609 a") = test { + val q1 = q"val x = 1" + val q2 = q"..$q1; val y = 2" + assert(q2 ≈ q"{ val x = 1; val y = 2 }") + } + + property("SI-8609 b") = test { + val q1 = q"import foo.bar" + val q2 = q"..$q1; val y = 2" + assert(q2 ≈ q"{ import foo.bar; val y = 2 }") + } } From 88d63f2d6b0864c86c7ebfcca78cb94cb9347639 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 15 May 2014 15:12:56 +0200 Subject: [PATCH 278/826] Cleanups for tracing in GenBCode, improve some comments --- .../scala/tools/nsc/backend/jvm/AsmUtils.scala | 8 ++++++++ src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala | 7 +++++-- .../scala/tools/nsc/backend/jvm/GenBCode.scala | 11 +++-------- src/compiler/scala/tools/nsc/transform/Mixin.scala | 2 +- 4 files changed, 17 insertions(+), 11 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala b/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala index 856f85d9e3a6..2af2037fec5c 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala @@ -8,6 +8,7 @@ package scala.tools.nsc.backend.jvm import scala.tools.asm.tree.{ClassNode, MethodNode} import java.io.PrintWriter import scala.tools.asm.util.{TraceClassVisitor, TraceMethodVisitor, Textifier} +import scala.tools.asm.ClassReader object AsmUtils { @@ -50,4 +51,11 @@ object AsmUtils { w.flush() } + def traceClass(bytes: Array[Byte]): Unit = traceClass(readClass(bytes)) + + def readClass(bytes: Array[Byte]): ClassNode = { + val node = new ClassNode() + new ClassReader(bytes).accept(node, 0) + node + } } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala index 13a5c6413d76..988c04f514f9 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala @@ -1401,7 +1401,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { // TODO param names: (m.params map (p => javaName(p.sym))) - // typestate: entering mode with valid call sequences: + // typestate: entering mode with valid call sequences: (see ASM Guide, 3.2.1) // [ visitAnnotationDefault ] ( visitAnnotation | visitParameterAnnotation | visitAttribute )* emitAnnotations(jmethod, others) @@ -1446,7 +1446,10 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { val hasStaticBitSet = ((flags & asm.Opcodes.ACC_STATIC) != 0) genCode(m, emitVars, hasStaticBitSet) - jmethod.visitMaxs(0, 0) // just to follow protocol, dummy arguments + // visitMaxs needs to be called according to the protocol. The arguments will be ignored + // since maximums (and stack map frames) are computed. See ASM Guide, Section 3.2.1, + // section "ClassWriter options" + jmethod.visitMaxs(0, 0) } jmethod.visitEnd() diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala index 61cf76f524f5..9b292fee7fb0 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala @@ -244,14 +244,9 @@ abstract class GenBCode extends BCodeSyncAndTry { val beanC = if (bean == null) null else SubItem3(bean.name, getByteArray(bean)) if (AsmUtils.traceSerializedClassEnabled && plain.name.contains(AsmUtils.traceSerializedClassPattern)) { - def readClass(bytes: Array[Byte]): asm.tree.ClassNode = { - val node = new asm.tree.ClassNode() - new asm.ClassReader(bytes).accept(node, 0) - node - } - if (mirrorC != null) AsmUtils.traceClass(readClass(mirrorC.jclassBytes)) - AsmUtils.traceClass(readClass(plainC.jclassBytes)) - if (beanC != null) AsmUtils.traceClass(readClass(beanC.jclassBytes)) + if (mirrorC != null) AsmUtils.traceClass(mirrorC.jclassBytes) + AsmUtils.traceClass(plainC.jclassBytes) + if (beanC != null) AsmUtils.traceClass(beanC.jclassBytes) } q3 add Item3(arrivalPos, mirrorC, plainC, beanC, outFolder) diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala index 33e8e47c765d..3ef85728da0a 100644 --- a/src/compiler/scala/tools/nsc/transform/Mixin.scala +++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala @@ -391,7 +391,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { else { sourceModule setPos sym.pos if (sourceModule.flags != MODULE) { - log("!!! Directly setting sourceModule flags from %s to MODULE".format(sourceModule.flagString)) + log("!!! Directly setting sourceModule flags for $sourceModule from %s to MODULE".format(sourceModule.flagString)) sourceModule.flags = MODULE } } From 805843dcd8aa955ac765d1789f891c7910156911 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Fri, 16 May 2014 15:17:15 +0200 Subject: [PATCH 279/826] Minor cleanups and commenting around BType. Use `length` instead of `size` on arrays in `reflect/internal/Names`. --- .../tools/nsc/backend/jvm/BCodeGlue.scala | 170 ++++++++++-------- .../scala/reflect/internal/Names.scala | 9 +- 2 files changed, 103 insertions(+), 76 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala index aa7e73a36b69..880b04790518 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala @@ -30,21 +30,23 @@ abstract class BCodeGlue extends SubComponent { // ------------- sorts ------------- - val VOID : Int = 0 - val BOOLEAN: Int = 1 - val CHAR : Int = 2 - val BYTE : Int = 3 - val SHORT : Int = 4 - val INT : Int = 5 - val FLOAT : Int = 6 - val LONG : Int = 7 - val DOUBLE : Int = 8 - val ARRAY : Int = 9 - val OBJECT : Int = 10 - val METHOD : Int = 11 + final val VOID = asm.Type.VOID + final val BOOLEAN = asm.Type.BOOLEAN + final val CHAR = asm.Type.CHAR + final val BYTE = asm.Type.BYTE + final val SHORT = asm.Type.SHORT + final val INT = asm.Type.INT + final val FLOAT = asm.Type.FLOAT + final val LONG = asm.Type.LONG + final val DOUBLE = asm.Type.DOUBLE + final val ARRAY = asm.Type.ARRAY + final val OBJECT = asm.Type.OBJECT + final val METHOD = asm.Type.METHOD // ------------- primitive types ------------- + // magic shifted numbers: see comment on class BType. This has been copied 1:1 from asm.Type. + val VOID_TYPE = new BType(VOID, ('V' << 24) | (5 << 16) | (0 << 8) | 0, 1) val BOOLEAN_TYPE = new BType(BOOLEAN, ('Z' << 24) | (0 << 16) | (5 << 8) | 1, 1) val CHAR_TYPE = new BType(CHAR, ('C' << 24) | (0 << 16) | (6 << 8) | 1, 1) @@ -99,7 +101,7 @@ abstract class BCodeGlue extends SubComponent { var resPos = off + 1 while (chrs(resPos) != ')') { resPos += 1 } val resType = getType(resPos + 1) - val len = resPos - off + 1 + resType.len; + val len = resPos - off + 1 + resType.len new BType( METHOD, off, @@ -116,7 +118,7 @@ abstract class BCodeGlue extends SubComponent { * can-multi-thread */ def getObjectType(index: Int, length: Int): BType = { - val sort = if (chrs(index) == '[') ARRAY else OBJECT; + val sort = if (chrs(index) == '[') ARRAY else OBJECT new BType(sort, index, length) } @@ -147,7 +149,7 @@ abstract class BCodeGlue extends SubComponent { /* * Returns the Java types corresponding to the argument types of method descriptor whose first argument starts at idx0. * - * @param idx0 index into chrs of the first argument. + * @param idx0 index into chrs of the first argument (after the '('). * @return the Java types corresponding to the argument types of the given method descriptor. * * can-multi-thread @@ -160,7 +162,7 @@ abstract class BCodeGlue extends SubComponent { while (chrs(off) != ')') { args(size) = getType(off) off += args(size).len - if (args(size).sort == OBJECT) { off += 2 } + if (args(size).sort == OBJECT) { off += 2 } // account for 'L' and ';' // debug: assert("LVZBSCIJFD[)".contains(chrs(off))) size += 1 } @@ -243,8 +245,31 @@ abstract class BCodeGlue extends SubComponent { } // end of object BType - /* - * Based on ASM's Type class. Namer's chrs is used in this class for the same purposes as the `buf` char array in asm.Type. + /** + * Based on ASM's Type class. Namer's chrs is used in this class for the same purposes as the + * `buf` char array in asm.Type. + * + * @param sort One of BType.VOID ... BType.METHOD + * + * @param off For array, object and method types, the offset of the type description in + * global.chrs. + * For primitive types, the `off` field contains + * - at byte 0 (& 0xff): the lenght, 0 for void, 2 for long/double, 1 otherwise + * - at byte 1 (& 0xff00): the Opcode offset for the corresponding xALOAD / xSTORE + * instruction. Example: Opcodes.IALOAD is 46, to load a boolean or a byte the + * necessary Opcode.BALOAD is 51, therefore the offset value is 5. + * - at byte 2 (& 0xff0000): the Opcode offset for other instructions (xLOAD, + * xSTORE, xADD, etc). See method BType#getOpcode. + * - at byte 3 (& 0xff000000): the descriptor ('V' for void, etc) + * For array types, the description starts with one or more '[' + * + * @param len The length of the type description + * - 1 for primitive types + * - For array, object and method types, the number of characters in global.chrs. + * Note: for array and method types, '[' and '(' and ')' are stored in the array + * and included in the length, for example "[Ljava/lang/Object;" or "()L...;" + * For object types, the leading 'L' and trailing ';' are not stored in the array + * and therefore excluded from the length, for example "java/lang/Object". * * All methods of this classs can-multi-thread */ @@ -255,34 +280,21 @@ abstract class BCodeGlue extends SubComponent { /* * can-multi-thread */ - def toASMType: scala.tools.asm.Type = { - import scala.tools.asm - // using `asm.Type.SHORT` instead of `BType.SHORT` because otherwise "warning: could not emit switch for @switch annotated match" - (sort: @switch) match { - case asm.Type.VOID => asm.Type.VOID_TYPE - case asm.Type.BOOLEAN => asm.Type.BOOLEAN_TYPE - case asm.Type.CHAR => asm.Type.CHAR_TYPE - case asm.Type.BYTE => asm.Type.BYTE_TYPE - case asm.Type.SHORT => asm.Type.SHORT_TYPE - case asm.Type.INT => asm.Type.INT_TYPE - case asm.Type.FLOAT => asm.Type.FLOAT_TYPE - case asm.Type.LONG => asm.Type.LONG_TYPE - case asm.Type.DOUBLE => asm.Type.DOUBLE_TYPE - case asm.Type.ARRAY | - asm.Type.OBJECT => asm.Type.getObjectType(getInternalName) - case asm.Type.METHOD => asm.Type.getMethodType(getDescriptor) - } + def toASMType: asm.Type = (sort: @switch) match { + case BType.VOID => asm.Type.VOID_TYPE + case BType.BOOLEAN => asm.Type.BOOLEAN_TYPE + case BType.CHAR => asm.Type.CHAR_TYPE + case BType.BYTE => asm.Type.BYTE_TYPE + case BType.SHORT => asm.Type.SHORT_TYPE + case BType.INT => asm.Type.INT_TYPE + case BType.FLOAT => asm.Type.FLOAT_TYPE + case BType.LONG => asm.Type.LONG_TYPE + case BType.DOUBLE => asm.Type.DOUBLE_TYPE + case BType.ARRAY | + BType.OBJECT => asm.Type.getObjectType(getInternalName) + case BType.METHOD => asm.Type.getMethodType(getDescriptor) } - /* - * Unlike for ICode's REFERENCE, isBoxedType(t) implies isReferenceType(t) - * Also, `isReferenceType(RT_NOTHING) == true` , similarly for RT_NULL. - * Use isNullType() , isNothingType() to detect Nothing and Null. - * - * can-multi-thread - */ - def hasObjectSort = (sort == BType.OBJECT) - /* * Returns the number of dimensions of this array type. This method should * only be used for an array type. @@ -292,6 +304,7 @@ abstract class BCodeGlue extends SubComponent { * can-multi-thread */ def getDimensions: Int = { + assert(isArray, s"getDimensions on non-array type $this") var i = 1 while (chrs(off + i) == '[') { i += 1 @@ -308,10 +321,33 @@ abstract class BCodeGlue extends SubComponent { * can-multi-thread */ def getElementType: BType = { - assert(isArray, s"Asked for the element type of a non-array type: $this") + assert(isArray, s"getElementType on non-array type $this") BType.getType(off + getDimensions) } + /* + * Element vs. Component type of an array: + * Quoting from the JVMS, Sec. 2.4 "Reference Types and Values" + * + * An array type consists of a component type with a single dimension (whose + * length is not given by the type). The component type of an array type may itself be + * an array type. If, starting from any array type, one considers its component type, + * and then (if that is also an array type) the component type of that type, and so on, + * eventually one must reach a component type that is not an array type; this is called + * the element type of the array type. The element type of an array type is necessarily + * either a primitive type, or a class type, or an interface type. + * + */ + + /* The type of items this array holds. + * + * can-multi-thread + */ + def getComponentType: BType = { + assert(isArray, s"Asked for the component type of a non-array type: $this") + BType.getType(off + 1) + } + /* * Returns the internal name of the class corresponding to this object or * array type. The internal name of a class is its fully qualified name (as @@ -323,6 +359,7 @@ abstract class BCodeGlue extends SubComponent { * can-multi-thread */ def getInternalName: String = { + assert(isRefOrArrayType, s"getInternalName on non-object, non-array type $this") new String(chrs, off, len) } @@ -332,7 +369,7 @@ abstract class BCodeGlue extends SubComponent { * can-multi-thread */ def getSimpleName: String = { - assert(hasObjectSort, s"not of object sort: $toString") + assert(hasObjectSort, s"getSimpleName on non-object $this") val iname = getInternalName val idx = iname.lastIndexOf('/') if (idx == -1) iname @@ -348,6 +385,7 @@ abstract class BCodeGlue extends SubComponent { * can-multi-thread */ def getArgumentTypes: Array[BType] = { + assert(sort == BType.METHOD, s"getArgumentTypes on non-method $this") BType.getArgumentTypes(off + 1) } @@ -360,7 +398,7 @@ abstract class BCodeGlue extends SubComponent { * can-multi-thread */ def getReturnType: BType = { - assert(chrs(off) == '(', s"doesn't look like a method descriptor: $toString") + assert(sort == BType.METHOD, s"getReturnType on non-method $this") var resPos = off + 1 while (chrs(resPos) != ')') { resPos += 1 } BType.getType(resPos + 1) @@ -375,6 +413,15 @@ abstract class BCodeGlue extends SubComponent { def isArray = (sort == BType.ARRAY) // can-multi-thread def isUnitType = (sort == BType.VOID) // can-multi-thread + /* + * Unlike for ICode's REFERENCE, isBoxedType(t) implies isReferenceType(t) + * Also, `isReferenceType(RT_NOTHING) == true` , similarly for RT_NULL. + * Use isNullType() , isNothingType() to detect Nothing and Null. + * + * can-multi-thread + */ + def hasObjectSort = (sort == BType.OBJECT) + def isRefOrArrayType = { hasObjectSort || isArray } // can-multi-thread def isNonUnitValueType = { isValueType && !isUnitType } // can-multi-thread @@ -442,29 +489,6 @@ abstract class BCodeGlue extends SubComponent { */ def isWideType = (getSize == 2) - /* - * Element vs. Component type of an array: - * Quoting from the JVMS, Sec. 2.4 "Reference Types and Values" - * - * An array type consists of a component type with a single dimension (whose - * length is not given by the type). The component type of an array type may itself be - * an array type. If, starting from any array type, one considers its component type, - * and then (if that is also an array type) the component type of that type, and so on, - * eventually one must reach a component type that is not an array type; this is called - * the element type of the array type. The element type of an array type is necessarily - * either a primitive type, or a class type, or an interface type. - * - */ - - /* The type of items this array holds. - * - * can-multi-thread - */ - def getComponentType: BType = { - assert(isArray, s"Asked for the component type of a non-array type: $this") - BType.getType(off + 1) - } - // ------------------------------------------------------------------------ // Conversion to type descriptors // ------------------------------------------------------------------------ @@ -532,7 +556,7 @@ abstract class BCodeGlue extends SubComponent { * can-multi-thread */ def getOpcode(opcode: Int): Int = { - import scala.tools.asm.Opcodes + import asm.Opcodes if (opcode == Opcodes.IALOAD || opcode == Opcodes.IASTORE) { // the offset for IALOAD or IASTORE is in byte 1 of 'off' for // primitive types (buf == null) @@ -594,7 +618,7 @@ abstract class BCodeGlue extends SubComponent { * can-multi-thread */ override def hashCode(): Int = { - var hc = 13 * sort; + var hc = 13 * sort if (sort >= BType.ARRAY) { var i = off val end = i + len @@ -621,7 +645,7 @@ abstract class BCodeGlue extends SubComponent { * * must-single-thread */ - def brefType(iname: String): BType = { brefType(newTypeName(iname.toCharArray(), 0, iname.length())) } + def brefType(iname: String): BType = brefType(newTypeName(iname.toCharArray(), 0, iname.length())) /* * Creates a BType token for the TypeName received as argument. diff --git a/src/reflect/scala/reflect/internal/Names.scala b/src/reflect/scala/reflect/internal/Names.scala index ae9f2da4e58a..fce1fc2a0cab 100644 --- a/src/reflect/scala/reflect/internal/Names.scala +++ b/src/reflect/scala/reflect/internal/Names.scala @@ -40,7 +40,10 @@ trait Names extends api.Names { /** Hashtable for finding type names quickly. */ private val typeHashtable = new Array[TypeName](HASH_SIZE) - /** The hashcode of a name. */ + /** + * The hashcode of a name depends on the first, the last and the middle character, + * and the length of the name. + */ private def hashValue(cs: Array[Char], offset: Int, len: Int): Int = if (len > 0) (len * (41 * 41 * 41) + @@ -158,9 +161,9 @@ trait Names extends api.Names { final def lookupTypeNameIfExisting(cs: Array[Char], failOnNotFound: Boolean): TypeName = { - val hterm = hashValue(cs, 0, cs.size) & HASH_MASK + val hterm = hashValue(cs, 0, cs.length) & HASH_MASK var nterm = termHashtable(hterm) - while ((nterm ne null) && (nterm.length != cs.size || !equals(nterm.start, cs, 0, cs.size))) { + while ((nterm ne null) && (nterm.length != cs.length || !equals(nterm.start, cs, 0, cs.length))) { nterm = nterm.next } if (nterm eq null) { From 9d80fd0148ba7466bbb47e661aea33ee930a0d32 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Fri, 16 May 2014 16:29:25 +0200 Subject: [PATCH 280/826] Cleanups in Names.scala Enter only fully constructed Name objects into the hash table, this should make lookupTypeName thread-safe. Clean up lookupTypeName - the hash code for a type name is the same as for its correspondent term name. Going from a type name toTermName should never create a new TermName instance. Assert that. --- .../scala/reflect/internal/Names.scala | 91 ++++++++----------- 1 file changed, 38 insertions(+), 53 deletions(-) diff --git a/src/reflect/scala/reflect/internal/Names.scala b/src/reflect/scala/reflect/internal/Names.scala index fce1fc2a0cab..05c060e81f0d 100644 --- a/src/reflect/scala/reflect/internal/Names.scala +++ b/src/reflect/scala/reflect/internal/Names.scala @@ -109,8 +109,13 @@ trait Names extends api.Names { // to enterChars cannot follow the construction of the TermName. val ncStart = nc enterChars(cs, offset, len) - if (cachedString ne null) new TermName_S(ncStart, len, h, cachedString) - else new TermName_R(ncStart, len, h) + val next = termHashtable(h) + val termName = + if (cachedString ne null) new TermName_S(ncStart, len, next, cachedString) + else new TermName_R(ncStart, len, next) + // Add the new termName to the hashtable only after it's been fully constructed + termHashtable(h) = termName + termName } } if (synchronizeNames) nameLock.synchronized(body) else body @@ -148,40 +153,20 @@ trait Names extends api.Names { newTermName(bs, offset, len).toTypeName /** - * Used only by the GenBCode backend, to represent bytecode-level types in a way that makes equals() and hashCode() efficient. - * For bytecode-level types of OBJECT sort, its internal name (not its descriptor) is stored. - * For those of ARRAY sort, its descriptor is stored ie has a leading '[' - * For those of METHOD sort, its descriptor is stored ie has a leading '(' + * Used by the GenBCode backend to lookup type names that are known to already exist. This method + * might be invoked in a multi-threaded setting. Invoking newTypeName instead might be unsafe. * - * can-multi-thread - * TODO SI-6240 !!! JZ Really? the constructors TermName and TypeName publish unconstructed `this` references - * into the hash tables; we could observe them here before the subclass constructor completes. + * can-multi-thread: names are added to the hash tables only after they are fully constructed. */ - final def lookupTypeName(cs: Array[Char]): TypeName = { lookupTypeNameIfExisting(cs, true) } + final def lookupTypeName(cs: Array[Char]): TypeName = { + val hash = hashValue(cs, 0, cs.length) & HASH_MASK + var typeName = typeHashtable(hash) - final def lookupTypeNameIfExisting(cs: Array[Char], failOnNotFound: Boolean): TypeName = { - - val hterm = hashValue(cs, 0, cs.length) & HASH_MASK - var nterm = termHashtable(hterm) - while ((nterm ne null) && (nterm.length != cs.length || !equals(nterm.start, cs, 0, cs.length))) { - nterm = nterm.next - } - if (nterm eq null) { - if (failOnNotFound) { assert(false, "TermName not yet created: " + new String(cs)) } - return null - } - - val htype = hashValue(chrs, nterm.start, nterm.length) & HASH_MASK - var ntype = typeHashtable(htype) - while ((ntype ne null) && ntype.start != nterm.start) { - ntype = ntype.next - } - if (ntype eq null) { - if (failOnNotFound) { assert(false, "TypeName not yet created: " + new String(cs)) } - return null + while ((typeName ne null) && (typeName.length != cs.length || !equals(typeName.start, cs, 0, cs.length))) { + typeName = typeName.next } - - ntype + assert(typeName != null, s"TypeName ${new String(cs)} not yet created.") + typeName } // Classes ---------------------------------------------------------------------- @@ -518,43 +503,47 @@ trait Names extends api.Names { /** TermName_S and TypeName_S have fields containing the string version of the name. * TermName_R and TypeName_R recreate it each time toString is called. */ - private final class TermName_S(index0: Int, len0: Int, hash: Int, override val toString: String) extends TermName(index0, len0, hash) { - protected def createCompanionName(h: Int): TypeName = new TypeName_S(index, len, h, toString) + private final class TermName_S(index0: Int, len0: Int, next0: TermName, override val toString: String) extends TermName(index0, len0, next0) { + protected def createCompanionName(next: TypeName): TypeName = new TypeName_S(index, len, next, toString) override def newName(str: String): TermName = newTermNameCached(str) } - private final class TypeName_S(index0: Int, len0: Int, hash: Int, override val toString: String) extends TypeName(index0, len0, hash) { - protected def createCompanionName(h: Int): TermName = new TermName_S(index, len, h, toString) + private final class TypeName_S(index0: Int, len0: Int, next0: TypeName, override val toString: String) extends TypeName(index0, len0, next0) { override def newName(str: String): TypeName = newTypeNameCached(str) } - private final class TermName_R(index0: Int, len0: Int, hash: Int) extends TermName(index0, len0, hash) { - protected def createCompanionName(h: Int): TypeName = new TypeName_R(index, len, h) + private final class TermName_R(index0: Int, len0: Int, next0: TermName) extends TermName(index0, len0, next0) { + protected def createCompanionName(next: TypeName): TypeName = new TypeName_R(index, len, next) override def toString = new String(chrs, index, len) } - private final class TypeName_R(index0: Int, len0: Int, hash: Int) extends TypeName(index0, len0, hash) { - protected def createCompanionName(h: Int): TermName = new TermName_R(index, len, h) + private final class TypeName_R(index0: Int, len0: Int, next0: TypeName) extends TypeName(index0, len0, next0) { override def toString = new String(chrs, index, len) } // SYNCNOTE: caller to constructor must synchronize if `synchronizeNames` is enabled - sealed abstract class TermName(index0: Int, len0: Int, hash: Int) extends Name(index0, len0) with TermNameApi { + sealed abstract class TermName(index0: Int, len0: Int, val next: TermName) extends Name(index0, len0) with TermNameApi { type ThisNameType = TermName protected[this] def thisName: TermName = this - val next: TermName = termHashtable(hash) - termHashtable(hash) = this + def isTermName: Boolean = true def isTypeName: Boolean = false def toTermName: TermName = this def toTypeName: TypeName = { def body = { + // Re-computing the hash saves a field for storing it in the TermName val h = hashValue(chrs, index, len) & HASH_MASK var n = typeHashtable(h) while ((n ne null) && n.start != index) n = n.next if (n ne null) n - else createCompanionName(h) + else { + val next = typeHashtable(h) + val typeName = createCompanionName(next) + // Add the new typeName to the hashtable only after it's been fully constructed + typeHashtable(h) = typeName + typeName + } } if (synchronizeNames) nameLock.synchronized(body) else body } @@ -565,7 +554,7 @@ trait Names extends api.Names { def nameKind = "term" /** SYNCNOTE: caller must synchronize if `synchronizeNames` is enabled */ - protected def createCompanionName(h: Int): TypeName + protected def createCompanionName(next: TypeName): TypeName } implicit val TermNameTag = ClassTag[TermName](classOf[TermName]) @@ -575,24 +564,22 @@ trait Names extends api.Names { def unapply(name: TermName): Option[String] = Some(name.toString) } - sealed abstract class TypeName(index0: Int, len0: Int, hash: Int) extends Name(index0, len0) with TypeNameApi { + sealed abstract class TypeName(index0: Int, len0: Int, val next: TypeName) extends Name(index0, len0) with TypeNameApi { type ThisNameType = TypeName protected[this] def thisName: TypeName = this - val next: TypeName = typeHashtable(hash) - typeHashtable(hash) = this - def isTermName: Boolean = false def isTypeName: Boolean = true def toTermName: TermName = { def body = { + // Re-computing the hash saves a field for storing it in the TypeName val h = hashValue(chrs, index, len) & HASH_MASK var n = termHashtable(h) while ((n ne null) && n.start != index) n = n.next - if (n ne null) n - else createCompanionName(h) + assert (n ne null, s"TypeName $this is missing its correspondent") + n } if (synchronizeNames) nameLock.synchronized(body) else body } @@ -604,8 +591,6 @@ trait Names extends api.Names { def nameKind = "type" override def decode = if (nameDebug) super.decode + "!" else super.decode - /** SYNCNOTE: caller must synchronize if `synchronizeNames` is enabled */ - protected def createCompanionName(h: Int): TermName } implicit val TypeNameTag = ClassTag[TypeName](classOf[TypeName]) From d190139373ef265b62f6ca499a1bc360b5fc0e8a Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Sat, 17 May 2014 07:58:34 +0200 Subject: [PATCH 281/826] Re-use the exsiting range of the name table when using subName. The sub-name can just point to a smaller range of the array. --- src/reflect/scala/reflect/internal/Names.scala | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/src/reflect/scala/reflect/internal/Names.scala b/src/reflect/scala/reflect/internal/Names.scala index 05c060e81f0d..b50f324074e1 100644 --- a/src/reflect/scala/reflect/internal/Names.scala +++ b/src/reflect/scala/reflect/internal/Names.scala @@ -107,12 +107,18 @@ trait Names extends api.Names { // The logic order here is future-proofing against the possibility // that name.toString will become an eager val, in which case the call // to enterChars cannot follow the construction of the TermName. - val ncStart = nc - enterChars(cs, offset, len) + var startIndex = 0 + if (cs == chrs) { + // Optimize for subName, the new name is already stored in chrs + startIndex = offset + } else { + startIndex = nc + enterChars(cs, offset, len) + } val next = termHashtable(h) val termName = - if (cachedString ne null) new TermName_S(ncStart, len, next, cachedString) - else new TermName_R(ncStart, len, next) + if (cachedString ne null) new TermName_S(startIndex, len, next, cachedString) + else new TermName_R(startIndex, len, next) // Add the new termName to the hashtable only after it's been fully constructed termHashtable(h) = termName termName From 0f2bf1db09455e019b99c21580afc87beab57d44 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Fri, 16 May 2014 22:44:52 +0200 Subject: [PATCH 282/826] More cleanups and commenting in GenBCode --- .../tools/nsc/backend/jvm/BCodeGlue.scala | 2 +- .../tools/nsc/backend/jvm/BCodeHelpers.scala | 26 +++++++++--------- .../tools/nsc/backend/jvm/BCodeTypes.scala | 27 ++++--------------- 3 files changed, 20 insertions(+), 35 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala index 880b04790518..4eecb4847302 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala @@ -653,7 +653,7 @@ abstract class BCodeGlue extends SubComponent { * * can-multi-thread */ - def brefType(iname: TypeName): BType = { BType.getObjectType(iname.start, iname.length) } + def brefType(iname: TypeName): BType = BType.getObjectType(iname.start, iname.length) // due to keyboard economy only val UNIT = BType.VOID_TYPE diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala index 3fdb38ce0e0e..d1684a91e68f 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala @@ -77,11 +77,12 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { */ final class CClassWriter(flags: Int) extends asm.ClassWriter(flags) { - /* - * This method is thread re-entrant because chrs never grows during its operation (that's because all TypeNames being looked up have already been entered). - * To stress this point, rather than using `newTypeName()` we use `lookupTypeName()` + /** + * This method is thread re-entrant because chrs never grows during its operation (that's + * because all TypeNames being looked up have already been entered). + * To stress this point, rather than using `newTypeName()` we use `lookupTypeName()` * - * can-multi-thread + * can-multi-thread */ override def getCommonSuperClass(inameA: String, inameB: String): String = { val a = brefType(lookupTypeName(inameA.toCharArray)) @@ -95,14 +96,15 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { } - /* - * Finding the least upper bound in agreement with the bytecode verifier (given two internal names handed out by ASM) - * Background: - * http://gallium.inria.fr/~xleroy/publi/bytecode-verification-JAR.pdf - * http://comments.gmane.org/gmane.comp.java.vm.languages/2293 - * https://issues.scala-lang.org/browse/SI-3872 + /** + * Finding the least upper bound in agreement with the bytecode verifier (given two internal names + * handed out by ASM) + * Background: + * http://gallium.inria.fr/~xleroy/publi/bytecode-verification-JAR.pdf + * http://comments.gmane.org/gmane.comp.java.vm.languages/2293 + * https://issues.scala-lang.org/browse/SI-3872 * - * can-multi-thread + * can-multi-thread */ def jvmWiseLUB(a: BType, b: BType): BType = { @@ -401,7 +403,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { * * must-single-thread */ - final def internalName(sym: Symbol): String = { asmClassType(sym).getInternalName } + final def internalName(sym: Symbol): String = asmClassType(sym).getInternalName /* * Tracks (if needed) the inner class given by `sym`. diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala index 1eca69936a30..a158fdd57039 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala @@ -24,8 +24,6 @@ abstract class BCodeTypes extends BCodeIdiomatic { // when compiling the Scala library, some assertions don't hold (e.g., scala.Boolean has null superClass although it's not an interface) val isCompilingStdLib = !(settings.sourcepath.isDefault) - val srBoxedUnit = brefType("scala/runtime/BoxedUnit") - // special names var StringReference : BType = null var ThrowableReference : BType = null @@ -350,8 +348,8 @@ abstract class BCodeTypes extends BCodeIdiomatic { val superInterfaces0: List[Symbol] = csym.mixinClasses val superInterfaces = existingSymbols(superInterfaces0 ++ csym.annotations.map(newParentForAttr)).distinct - assert(!superInterfaces.contains(NoSymbol), s"found NoSymbol among: ${superInterfaces.mkString}") - assert(superInterfaces.forall(s => s.isInterface || s.isTrait), s"found non-interface among: ${superInterfaces.mkString}") + assert(!superInterfaces.contains(NoSymbol), s"found NoSymbol among: ${superInterfaces.mkString(", ")}") + assert(superInterfaces.forall(s => s.isInterface || s.isTrait), s"found non-interface among: ${superInterfaces.mkString(", ")}") minimizeInterfaces(superInterfaces) } @@ -395,8 +393,6 @@ abstract class BCodeTypes extends BCodeIdiomatic { tr } - val EMPTY_TRACKED_ARRAY = Array.empty[Tracked] - /* * must-single-thread */ @@ -413,14 +409,7 @@ abstract class BCodeTypes extends BCodeIdiomatic { ((sc != NoSymbol) && !sc.isInterface) || isCompilingStdLib, "superClass out of order" ) - val ifaces = getSuperInterfaces(csym) map exemplar; - val ifacesArr = - if (ifaces.isEmpty) EMPTY_TRACKED_ARRAY - else { - val arr = new Array[Tracked](ifaces.size) - ifaces.copyToArray(arr) - arr - } + val ifacesArr = getSuperInterfaces(csym).map(exemplar).toArray val flags = mkFlags( javaFlags(csym), @@ -724,14 +713,8 @@ abstract class BCodeTypes extends BCodeIdiomatic { } } - // now that we have all of `ics` , `csym` , and soon the inner-classes-chain, it's too tempting not to cache. - if (chain.isEmpty) { null } - else { - val arr = new Array[InnerClassEntry](chain.size) - (chain map toInnerClassEntry).copyToArray(arr) - - arr - } + if (chain.isEmpty) null + else chain.map(toInnerClassEntry).toArray } /* From 70d179084673fa317c4380529c9ab58f42de19e8 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Mon, 19 May 2014 09:58:34 +0200 Subject: [PATCH 283/826] Move class BType to separate component, include it by composition. Rewire BType in its new location with the rest of the backend. Remove the now-empty BCodeGlue. --- .../nsc/backend/jvm/BCodeBodyBuilder.scala | 1 + .../tools/nsc/backend/jvm/BCodeHelpers.scala | 2 +- .../nsc/backend/jvm/BCodeIdiomatic.scala | 10 +- .../nsc/backend/jvm/BCodeSkelBuilder.scala | 1 + .../nsc/backend/jvm/BCodeSyncAndTry.scala | 1 + .../tools/nsc/backend/jvm/BCodeTypes.scala | 2 +- .../jvm/{BCodeGlue.scala => BTypes.scala} | 117 +++++++++--------- 7 files changed, 72 insertions(+), 62 deletions(-) rename src/compiler/scala/tools/nsc/backend/jvm/{BCodeGlue.scala => BTypes.scala} (91%) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index 3d1b646069a2..4af1b553169e 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -24,6 +24,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { import global._ import definitions._ import bCodeICodeCommon._ + import bTypes._ /* * Functionality to build the body of ASM MethodNode, except for `synchronized` and `try` expressions. diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala index d1684a91e68f..d812f6b58d13 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala @@ -20,8 +20,8 @@ import scala.tools.nsc.io.AbstractFile * */ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { - import global._ + import bTypes._ /* * must-single-thread diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala index f9f6e7c3ff09..e83453f51e60 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala @@ -19,9 +19,17 @@ import collection.convert.Wrappers.JListWrapper * @version 1.0 * */ -abstract class BCodeIdiomatic extends BCodeGlue { +abstract class BCodeIdiomatic extends SubComponent { + protected val bCodeICodeCommon: BCodeICodeCommon[global.type] = new BCodeICodeCommon(global) + + val bTypes = new BTypes[global.type](global) { + def chrs = global.chrs + override type BTypeName = global.TypeName + override def createNewName(s: String) = global.newTypeName(s) + } import global._ + import bTypes._ val classfileVersion: Int = settings.target.value match { case "jvm-1.5" => asm.Opcodes.V1_5 diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala index a76fa4d7ba0d..a9ba1945d20b 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala @@ -25,6 +25,7 @@ import java.io.PrintWriter */ abstract class BCodeSkelBuilder extends BCodeHelpers { import global._ + import bTypes._ /* * There's a dedicated PlainClassBuilder for each CompilationUnit, diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala index 9ddb7a3ce832..5801b5e09c6b 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala @@ -22,6 +22,7 @@ import scala.tools.asm */ abstract class BCodeSyncAndTry extends BCodeBodyBuilder { import global._ + import bTypes._ /* diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala index a158fdd57039..20c2c5210361 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala @@ -18,8 +18,8 @@ import scala.collection.{ immutable, mutable } * */ abstract class BCodeTypes extends BCodeIdiomatic { - import global._ + import bTypes._ // when compiling the Scala library, some assertions don't hold (e.g., scala.Boolean has null superClass although it's not an interface) val isCompilingStdLib = !(settings.sourcepath.isDefault) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala similarity index 91% rename from src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala rename to src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala index 4eecb4847302..0c5dcd2908fc 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeGlue.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala @@ -1,33 +1,53 @@ -/* NSC -- new Scala compiler - * Copyright 2005-2012 LAMP/EPFL - * @author Martin Odersky - */ - -package scala -package tools.nsc +package scala.tools.nsc package backend.jvm -import scala.tools.asm +import scala.collection.immutable import scala.annotation.switch -import scala.collection.{ immutable, mutable } +import scala.tools.asm -/* - * Immutable representations of bytecode-level types. +/** + * BTypes is a backend component that defines the class BType, a number of basic instances and + * some utilities. * - * @author Miguel Garcia, http://lamp.epfl.ch/~magarcia/ScalaCompilerCornerReloaded - * @version 1.0 + * A BType is essentially an slice of the array `chrs` denoting the name of the type, and a field + * denoting the kind (object, array, method, or one of the primitive types). * + * BTypes depends on Global just because it re-uses hash-consing of Name. It would be cleaner to + * create an interface for BTypeName and extend it in scala.reflect.internal.Names#Name, that + * would simplify testing BTypes (no Global needed). */ -abstract class BCodeGlue extends SubComponent { +abstract class BTypes[G <: Global](val __global_dont_use: G) { + def chrs: Array[Char] - import global._ + /** + * Interface for names stored in `chrs` + */ + type BTypeName <: __global_dont_use.Name - protected val bCodeICodeCommon: BCodeICodeCommon[global.type] = new BCodeICodeCommon(global) + /** + * Create a new name in `chrs`. Names are assumed to be hash-consed. Equality on BType will use + * reference equality to compare the names. + */ + def createNewName(s: String): BTypeName - object BType { + /** + * Creates a BType for the class, interface or array descriptor `iname`. + * + * must-single-thread + */ + def brefType(iname: String): BType = brefType(createNewName(iname)) - import global.chrs + /** + * Creates a BType for the class, interface or array descriptor `iname`. + * + * can-multi-thread + */ + def brefType(iname: BTypeName): BType = BType.getObjectType(iname.start, iname.length) + /** + * TODO @lry : make members private to BType, move those used outside into the BTypes component + */ + object BType { // ------------- sorts ------------- final val VOID = asm.Type.VOID @@ -128,7 +148,7 @@ abstract class BCodeGlue extends SubComponent { * must-single-thread */ def getMethodType(methodDescriptor: String): BType = { - val n = global.newTypeName(methodDescriptor) + val n = createNewName(methodDescriptor) new BType(BType.METHOD, n.start, n.length) // TODO assert isValidMethodDescriptor } @@ -142,7 +162,7 @@ abstract class BCodeGlue extends SubComponent { * must-single-thread */ def getMethodType(returnType: BType, argumentTypes: Array[BType]): BType = { - val n = global.newTypeName(getMethodDescriptor(returnType, argumentTypes)) + val n = createNewName(getMethodDescriptor(returnType, argumentTypes)) new BType(BType.METHOD, n.start, n.length) } @@ -210,7 +230,7 @@ abstract class BCodeGlue extends SubComponent { * must-single-thread */ def getReturnType(methodDescriptor: String): BType = { - val n = global.newTypeName(methodDescriptor) + val n = createNewName(methodDescriptor) val delta = n.pos(')') // `delta` is relative to the Name's zero-based start position, not a valid index into chrs. assert(delta < n.length, s"not a valid method descriptor: $methodDescriptor") getType(n.start + delta + 1) @@ -228,8 +248,8 @@ abstract class BCodeGlue extends SubComponent { * can-multi-thread */ def getMethodDescriptor( - returnType: BType, - argumentTypes: Array[BType]): String = + returnType: BType, + argumentTypes: Array[BType]): String = { val buf = new StringBuffer() buf.append('(') @@ -251,8 +271,7 @@ abstract class BCodeGlue extends SubComponent { * * @param sort One of BType.VOID ... BType.METHOD * - * @param off For array, object and method types, the offset of the type description in - * global.chrs. + * @param off For array, object and method types, the offset of the type description in chrs. * For primitive types, the `off` field contains * - at byte 0 (& 0xff): the lenght, 0 for void, 2 for long/double, 1 otherwise * - at byte 1 (& 0xff00): the Opcode offset for the corresponding xALOAD / xSTORE @@ -265,18 +284,15 @@ abstract class BCodeGlue extends SubComponent { * * @param len The length of the type description * - 1 for primitive types - * - For array, object and method types, the number of characters in global.chrs. + * - For array, object and method types, the number of characters in chrs. * Note: for array and method types, '[' and '(' and ')' are stored in the array - * and included in the length, for example "[Ljava/lang/Object;" or "()L...;" + * and included in the length, for example "[Ljava/lang/Object;" or "(I)L...;" * For object types, the leading 'L' and trailing ';' are not stored in the array * and therefore excluded from the length, for example "java/lang/Object". * * All methods of this classs can-multi-thread */ final class BType(val sort: Int, val off: Int, val len: Int) { - - import global.chrs - /* * can-multi-thread */ @@ -438,9 +454,9 @@ abstract class BCodeGlue extends SubComponent { case BOXED_UNIT | BOXED_BOOLEAN | BOXED_CHAR | BOXED_BYTE | BOXED_SHORT | BOXED_INT | BOXED_FLOAT | BOXED_LONG | BOXED_DOUBLE - => true + => true case _ - => false + => false } } @@ -454,9 +470,9 @@ abstract class BCodeGlue extends SubComponent { (sort : @switch) match { case BType.BOOLEAN | BType.CHAR | BType.BYTE | BType.SHORT | BType.INT - => true + => true case _ - => false + => false } } @@ -469,9 +485,9 @@ abstract class BCodeGlue extends SubComponent { case BType.CHAR | BType.BYTE | BType.SHORT | BType.INT | BType.LONG - => true + => true case _ - => false + => false } } @@ -635,27 +651,9 @@ abstract class BCodeGlue extends SubComponent { * * can-multi-thread */ - override def toString: String = { getDescriptor } - + override def toString: String = getDescriptor } - /* - * Creates a TypeName and the BType token for it. - * This method does not add to `innerClassBufferASM`, use `internalName()` or `asmType()` or `toTypeKind()` for that. - * - * must-single-thread - */ - def brefType(iname: String): BType = brefType(newTypeName(iname.toCharArray(), 0, iname.length())) - - /* - * Creates a BType token for the TypeName received as argument. - * This method does not add to `innerClassBufferASM`, use `internalName()` or `asmType()` or `toTypeKind()` for that. - * - * can-multi-thread - */ - def brefType(iname: TypeName): BType = BType.getObjectType(iname.start, iname.length) - - // due to keyboard economy only val UNIT = BType.VOID_TYPE val BOOL = BType.BOOLEAN_TYPE val CHAR = BType.CHAR_TYPE @@ -684,8 +682,8 @@ abstract class BCodeGlue extends SubComponent { */ val RT_NOTHING = brefType("scala/runtime/Nothing$") val RT_NULL = brefType("scala/runtime/Null$") - val CT_NOTHING = brefType("scala/Nothing") // TODO needed? - val CT_NULL = brefType("scala/Null") // TODO needed? + val CT_NOTHING = brefType("scala/Nothing") + val CT_NULL = brefType("scala/Null") val srBooleanRef = brefType("scala/runtime/BooleanRef") val srByteRef = brefType("scala/runtime/ByteRef") @@ -714,7 +712,7 @@ abstract class BCodeGlue extends SubComponent { case class MethodNameAndType(mname: String, mdesc: String) - val asmBoxTo: Map[BType, MethodNameAndType] = { + val asmBoxTo: immutable.Map[BType, MethodNameAndType] = { Map( BOOL -> MethodNameAndType("boxToBoolean", "(Z)Ljava/lang/Boolean;" ) , BYTE -> MethodNameAndType("boxToByte", "(B)Ljava/lang/Byte;" ) , @@ -727,7 +725,7 @@ abstract class BCodeGlue extends SubComponent { ) } - val asmUnboxTo: Map[BType, MethodNameAndType] = { + val asmUnboxTo: immutable.Map[BType, MethodNameAndType] = { Map( BOOL -> MethodNameAndType("unboxToBoolean", "(Ljava/lang/Object;)Z") , BYTE -> MethodNameAndType("unboxToByte", "(Ljava/lang/Object;)B") , @@ -740,3 +738,4 @@ abstract class BCodeGlue extends SubComponent { ) } } + From 85af6f0f7dc74e67149e8d8fc392c3cc97134cca Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Thu, 22 May 2014 12:02:09 -0700 Subject: [PATCH 284/826] SI-5905 Clarify test case The language feature options are discovered reflectively, but it is nice to enforce that expected options are supplied. Short of that, the code string includes a rowdy postfix operator. It still does enforce that at least one option was discovered. --- test/files/run/t5905-features.scala | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/test/files/run/t5905-features.scala b/test/files/run/t5905-features.scala index a3848eef2ae9..b518d611455f 100644 --- a/test/files/run/t5905-features.scala +++ b/test/files/run/t5905-features.scala @@ -3,13 +3,13 @@ import tools.partest.DirectTest // verify that all languageFeature names are accepted by -language object Test extends DirectTest { - override def code = "class Code { def f = (1 to 10) size }" // exercise a feature + override def code = "class Code { def f = (1 to 10) size }" // exercise a feature to sanity-check coverage of -language options override def extraSettings = s"-usejavacp -d ${testOutput.path}" override def show() = { - val global = newCompiler("-language:postfixOps", "-Ystop-after:typer") - compileString(global)(code) + val global = newCompiler("-Ystop-after:typer") + compileString(global)("") // warm me up, scotty import global._ exitingTyper { //def isFeature(s: Symbol) = s.annotations.exists((a: AnnotationInfo) => a.tpe <:< typeOf[scala.annotation.meta.languageFeature]) @@ -21,6 +21,8 @@ object Test extends DirectTest { assert(feats.nonEmpty, "Test must find feature flags.") + //compile("junk") // tragically, does not fail the test, i.e., arg must not be totally borked + //dynamics,postfixOps,reflectiveCalls,implicitConversions,higherKinds,existentials,experimental.macros compile(s"-language:$all") } From a907887158a469b6a21d027fd37bc360e9009b2f Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Thu, 22 May 2014 22:21:10 +0200 Subject: [PATCH 285/826] adds MacroPlugin.pluginsIsBlackbox This is an important omission in the current macro plugin API, which was designed before the blackbox vs whitebox separation was implemented. Even if one overrides pluginsTypedMacroBody and pluginsMacroExpand, that would still be not enough to write a custom macro expander, because typedImplicit1 uses isBlackbox, which is tightly coupled with the standard way of reading/writing macro signatures. --- .../nsc/typechecker/AnalyzerPlugins.scala | 18 ++++++++++++++++ .../scala/tools/nsc/typechecker/Macros.scala | 7 ++++++- .../macroPlugins-isBlackbox/Macros_2.scala | 11 ++++++++++ .../macroPlugins-isBlackbox/Plugin_1.scala | 21 +++++++++++++++++++ .../run/macroPlugins-isBlackbox/Test_3.flags | 1 + .../run/macroPlugins-isBlackbox/Test_3.scala | 3 +++ .../macroPlugins-isBlackbox/scalac-plugin.xml | 4 ++++ 7 files changed, 64 insertions(+), 1 deletion(-) create mode 100644 test/files/run/macroPlugins-isBlackbox/Macros_2.scala create mode 100644 test/files/run/macroPlugins-isBlackbox/Plugin_1.scala create mode 100644 test/files/run/macroPlugins-isBlackbox/Test_3.flags create mode 100644 test/files/run/macroPlugins-isBlackbox/Test_3.scala create mode 100644 test/files/run/macroPlugins-isBlackbox/scalac-plugin.xml diff --git a/src/compiler/scala/tools/nsc/typechecker/AnalyzerPlugins.scala b/src/compiler/scala/tools/nsc/typechecker/AnalyzerPlugins.scala index fa6e5399eb9d..5a70d4c524c0 100644 --- a/src/compiler/scala/tools/nsc/typechecker/AnalyzerPlugins.scala +++ b/src/compiler/scala/tools/nsc/typechecker/AnalyzerPlugins.scala @@ -189,6 +189,16 @@ trait AnalyzerPlugins { self: Analyzer => */ def pluginsTypedMacroBody(typer: Typer, ddef: DefDef): Option[Tree] = None + /** + * Figures out whether the given macro definition is blackbox or whitebox. + * + * Default implementation provided in `self.standardIsBlackbox` loads the macro impl binding + * and fetches boxity from the "isBlackbox" field of the macro signature. + * + * $nonCumulativeReturnValueDoc. + */ + def pluginsIsBlackbox(macroDef: Symbol): Option[Boolean] = None + /** * Expands an application of a def macro (i.e. of a symbol that has the MACRO flag set), * possibly using the current typer mode and the provided prototype. @@ -375,6 +385,14 @@ trait AnalyzerPlugins { self: Analyzer => def custom(plugin: MacroPlugin) = plugin.pluginsTypedMacroBody(typer, ddef) }) + /** @see MacroPlugin.pluginsIsBlackbox */ + def pluginsIsBlackbox(macroDef: Symbol): Boolean = invoke(new NonCumulativeOp[Boolean] { + def position = macroDef.pos + def description = "compute boxity for this macro definition" + def default = standardIsBlackbox(macroDef) + def custom(plugin: MacroPlugin) = plugin.pluginsIsBlackbox(macroDef) + }) + /** @see MacroPlugin.pluginsMacroExpand */ def pluginsMacroExpand(typer: Typer, expandee: Tree, mode: Mode, pt: Type): Tree = invoke(new NonCumulativeOp[Tree] { def position = expandee.pos diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala index f4456998c05c..aa7a57093760 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala @@ -263,7 +263,12 @@ trait Macros extends MacroRuntimes with Traces with Helpers { } def isBlackbox(expandee: Tree): Boolean = isBlackbox(dissectApplied(expandee).core.symbol) - def isBlackbox(macroDef: Symbol): Boolean = { + def isBlackbox(macroDef: Symbol): Boolean = pluginsIsBlackbox(macroDef) + + /** Default implementation of `isBlackbox`. + * Can be overridden by analyzer plugins (see AnalyzerPlugins.pluginsIsBlackbox for more details) + */ + def standardIsBlackbox(macroDef: Symbol): Boolean = { val fastTrackBoxity = fastTrack.get(macroDef).map(_.isBlackbox) val bindingBoxity = loadMacroImplBinding(macroDef).map(_.isBlackbox) fastTrackBoxity orElse bindingBoxity getOrElse false diff --git a/test/files/run/macroPlugins-isBlackbox/Macros_2.scala b/test/files/run/macroPlugins-isBlackbox/Macros_2.scala new file mode 100644 index 000000000000..a90dd702dfe9 --- /dev/null +++ b/test/files/run/macroPlugins-isBlackbox/Macros_2.scala @@ -0,0 +1,11 @@ +import scala.language.experimental.macros +import scala.reflect.macros.blackbox.Context + +object Macros { + def impl(c: Context) = { + import c.universe._ + q"42" + } + + def foo: Any = macro impl +} \ No newline at end of file diff --git a/test/files/run/macroPlugins-isBlackbox/Plugin_1.scala b/test/files/run/macroPlugins-isBlackbox/Plugin_1.scala new file mode 100644 index 000000000000..b78a18ea6a76 --- /dev/null +++ b/test/files/run/macroPlugins-isBlackbox/Plugin_1.scala @@ -0,0 +1,21 @@ +package isblackbox + +import scala.tools.nsc.Global +import scala.tools.nsc.plugins.{Plugin => NscPlugin} + +class Plugin(val global: Global) extends NscPlugin { + import global._ + import analyzer._ + import scala.reflect.internal.Mode + + val name = "isBlackbox" + val description = "A sample analyzer plugin that overrides isBlackbox." + val components = Nil + addMacroPlugin(MacroPlugin) + + object MacroPlugin extends MacroPlugin { + override def pluginsIsBlackbox(macroDef: Symbol): Option[Boolean] = { + Some(false) + } + } +} \ No newline at end of file diff --git a/test/files/run/macroPlugins-isBlackbox/Test_3.flags b/test/files/run/macroPlugins-isBlackbox/Test_3.flags new file mode 100644 index 000000000000..966df731d030 --- /dev/null +++ b/test/files/run/macroPlugins-isBlackbox/Test_3.flags @@ -0,0 +1 @@ +-Xplugin:. \ No newline at end of file diff --git a/test/files/run/macroPlugins-isBlackbox/Test_3.scala b/test/files/run/macroPlugins-isBlackbox/Test_3.scala new file mode 100644 index 000000000000..552e888143c7 --- /dev/null +++ b/test/files/run/macroPlugins-isBlackbox/Test_3.scala @@ -0,0 +1,3 @@ +object Test extends App { + val x: Int = Macros.foo +} \ No newline at end of file diff --git a/test/files/run/macroPlugins-isBlackbox/scalac-plugin.xml b/test/files/run/macroPlugins-isBlackbox/scalac-plugin.xml new file mode 100644 index 000000000000..09b9c14648b1 --- /dev/null +++ b/test/files/run/macroPlugins-isBlackbox/scalac-plugin.xml @@ -0,0 +1,4 @@ + + is-blackbox + isblackbox.Plugin + \ No newline at end of file From 302bed032d63784a8f4322d77f2403b954902823 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Fri, 23 May 2014 12:09:11 +0200 Subject: [PATCH 286/826] Bump version number to 2.11.2 --- build.number | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.number b/build.number index 63a55339b983..4a0898529e31 100644 --- a/build.number +++ b/build.number @@ -1,7 +1,7 @@ #Tue Sep 11 19:21:09 CEST 2007 version.major=2 version.minor=11 -version.patch=1 +version.patch=2 # This is the -N part of a version. if it's 0, it's dropped from maven versions. version.bnum=0 From fcb3932b32a2133612473e7b061859f97aa562df Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Fri, 23 May 2014 12:26:08 +0200 Subject: [PATCH 287/826] macro args now correctly preserve range positions Somewhen in the 2.11.0 development cycle we started duplicating macro arguments for increased robustness. What wasn't taken into account though is that Tree.duplicate destroys range positions. This commit fixes the problem. 2.10.x is unaffected by this bug, because it doesn't duplicate the args yet. --- src/compiler/scala/tools/nsc/typechecker/Macros.scala | 5 +++-- test/files/run/macro-rangepos-args.check | 1 + test/files/run/macro-rangepos-args.flags | 1 + test/files/run/macro-rangepos-args/Macros_1.scala | 10 ++++++++++ test/files/run/macro-rangepos-args/Test_2.scala | 4 ++++ 5 files changed, 19 insertions(+), 2 deletions(-) create mode 100644 test/files/run/macro-rangepos-args.check create mode 100644 test/files/run/macro-rangepos-args.flags create mode 100644 test/files/run/macro-rangepos-args/Macros_1.scala create mode 100644 test/files/run/macro-rangepos-args/Test_2.scala diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala index f4456998c05c..f40a92f8e570 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala @@ -417,9 +417,10 @@ trait Macros extends MacroRuntimes with Traces with Helpers { val wrappedArgs = mapWithIndex(args)((arg, j) => { val fingerprint = implParams(min(j, implParams.length - 1)) + val duplicatedArg = duplicateAndKeepPositions(arg) fingerprint match { - case LiftedTyped => context.Expr[Nothing](arg.duplicate)(TypeTag.Nothing) // TODO: SI-5752 - case LiftedUntyped => arg.duplicate + case LiftedTyped => context.Expr[Nothing](duplicatedArg)(TypeTag.Nothing) // TODO: SI-5752 + case LiftedUntyped => duplicatedArg case _ => abort(s"unexpected fingerprint $fingerprint in $binding with paramss being $paramss " + s"corresponding to arg $arg in $argss") } diff --git a/test/files/run/macro-rangepos-args.check b/test/files/run/macro-rangepos-args.check new file mode 100644 index 000000000000..d779505c66c1 --- /dev/null +++ b/test/files/run/macro-rangepos-args.check @@ -0,0 +1 @@ +Line: 3. Width: 5. diff --git a/test/files/run/macro-rangepos-args.flags b/test/files/run/macro-rangepos-args.flags new file mode 100644 index 000000000000..fcf951d90723 --- /dev/null +++ b/test/files/run/macro-rangepos-args.flags @@ -0,0 +1 @@ +-Yrangepos \ No newline at end of file diff --git a/test/files/run/macro-rangepos-args/Macros_1.scala b/test/files/run/macro-rangepos-args/Macros_1.scala new file mode 100644 index 000000000000..97b938613c5d --- /dev/null +++ b/test/files/run/macro-rangepos-args/Macros_1.scala @@ -0,0 +1,10 @@ +import scala.language.experimental.macros +import scala.reflect.macros.blackbox.Context + +object Macros { + def impl(c: Context)(x: c.Tree): c.Tree = { + import c.universe._ + Literal(Constant(s"Line: ${x.pos.line}. Width: ${x.pos.end - x.pos.start}.")) + } + def pos(x: Any): String = macro impl +} diff --git a/test/files/run/macro-rangepos-args/Test_2.scala b/test/files/run/macro-rangepos-args/Test_2.scala new file mode 100644 index 000000000000..8c770e901075 --- /dev/null +++ b/test/files/run/macro-rangepos-args/Test_2.scala @@ -0,0 +1,4 @@ +object Test extends App { + val x = 2 + println(Macros.pos(x + 2)) +} \ No newline at end of file From 733224093d8fee6f624656ecb9ee7c596fdb5ec2 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Fri, 23 May 2014 11:34:17 -0700 Subject: [PATCH 288/826] SI-8494 Restore filtering javap output Regressed in support for new delayedEndPoint, where it must pick what to filter for. `s/claas/klass/` and similar. --- .../tools/nsc/interpreter/JavapClass.scala | 77 +++++++++++-------- 1 file changed, 44 insertions(+), 33 deletions(-) diff --git a/src/repl/scala/tools/nsc/interpreter/JavapClass.scala b/src/repl/scala/tools/nsc/interpreter/JavapClass.scala index 915fd57bf876..f3ffea5a9b97 100644 --- a/src/repl/scala/tools/nsc/interpreter/JavapClass.scala +++ b/src/repl/scala/tools/nsc/interpreter/JavapClass.scala @@ -41,16 +41,16 @@ class JavapClass( * Byte data for filename args is retrieved with findBytes. */ def apply(args: Seq[String]): List[JpResult] = { - val (options, claases) = args partition (s => (s startsWith "-") && s.length > 1) + val (options, classes) = args partition (s => (s startsWith "-") && s.length > 1) val (flags, upgraded) = upgrade(options) import flags.{ app, fun, help, raw } - val targets = if (fun && !help) FunFinder(loader, intp).funs(claases) else claases - if (help || claases.isEmpty) + val targets = if (fun && !help) FunFinder(loader, intp).funs(classes) else classes + if (help || classes.isEmpty) List(JpResult(JavapTool.helper(printWriter))) else if (targets.isEmpty) List(JpResult("No anonfuns found.")) else - tool(raw, upgraded)(targets map (claas => targeted(claas, app))) + tool(raw, upgraded)(targets map (klass => targeted(klass, app))) } /** Cull our tool options. */ @@ -67,17 +67,18 @@ class JavapClass( case f: Failure[_] => (path, Failure(f.exception)) } - /** Find bytes. Handle "-", "-app", "Foo#bar" (by ignoring member), "#bar" (by taking "bar"). */ + /** Find bytes. Handle "-", "-app", "Foo#bar" (by ignoring member), "#bar" (by taking "bar"). + * @return the path to use for filtering, and the byte array + */ private def bytesFor(path: String, app: Boolean) = Try { def last = intp.get.mostRecentVar // fail if no intp - def req = path match { - case "-" => last - case HashSplit(prefix, member) => - if (prefix != null) prefix - else if (member != null) member - else "#" + val req = path match { + case "-" => last + case HashSplit(prefix, _) if prefix != null => prefix + case HashSplit(_, member) if member != null => member + case s => s } - val targetedBytes = if (app) findAppBody(req) else (req, findBytes(req)) + val targetedBytes = if (app) findAppBody(req) else (path, findBytes(req)) if (targetedBytes._2.isEmpty) throw new FileNotFoundException(s"Could not find class bytes for '$path'") targetedBytes } @@ -217,15 +218,15 @@ class JavapClass( // if apply is added here, it's for other than -fun: javap Foo#, perhaps m#? val filterOn = target.splitHashMember._2 map { s => if (s.isEmpty) "apply" else s } var filtering = false // true if in region matching filter - // true to output - def checkFilter(line: String) = if (filterOn.isEmpty) true else { + // turn filtering on/off given the pattern of interest + def filterStatus(line: String, pattern: String) = { // cheap heuristic, todo maybe parse for the java sig. // method sigs end in paren semi def isAnyMethod = line.endsWith(");") def isOurMethod = { val lparen = line.lastIndexOf('(') val blank = line.lastIndexOf(' ', lparen) - (blank >= 0 && line.substring(blank+1, lparen) == filterOn.get) + (blank >= 0 && line.substring(blank+1, lparen) == pattern) } filtering = if (filtering) { // next blank line terminates section @@ -236,8 +237,12 @@ class JavapClass( } filtering } - for (line <- Source.fromString(preamble + written).getLines(); if checkFilter(line)) - printWriter write line+lineSeparator + // do we output this line? + def checkFilter(line: String) = filterOn map (filterStatus(line, _)) getOrElse true + for { + line <- Source.fromString(preamble + written).getLines() + if checkFilter(line) + } printWriter write f"$line%n" printWriter.flush() } } @@ -275,7 +280,7 @@ class JavapClass( override def apply(raw: Boolean, options: Seq[String])(inputs: Seq[Input]): List[JpResult] = (inputs map { - case (claas, Success(ba)) => JpResult(showable(raw, claas, newPrinter(new ByteArrayInputStream(ba), newEnv(options)))) + case (klass, Success(ba)) => JpResult(showable(raw, klass, newPrinter(new ByteArrayInputStream(ba), newEnv(options)))) case (_, Failure(e)) => JpResult(e.toString) }).toList orFailed List(noToolError) } @@ -290,10 +295,10 @@ class JavapClass( //object TaskResult extends Enumeration { // val Ok, Error, CmdErr, SysErr, Abnormal = Value //} - val TaskClaas = loader.tryToInitializeClass[Task](JavapTool.Tool).orNull - override protected def failed = TaskClaas eq null + val TaskClass = loader.tryToInitializeClass[Task](JavapTool.Tool).orNull + override protected def failed = TaskClass eq null - val TaskCtor = TaskClaas.getConstructor( + val TaskCtor = TaskClass.getConstructor( classOf[Writer], classOf[JavaFileManager], classOf[DiagnosticListener[_]], @@ -344,8 +349,12 @@ class JavapClass( import Kind._ import StandardLocation._ import JavaFileManager.Location - import java.net.URI - def uri(name: String): URI = new URI(name) // new URI("jfo:" + name) + import java.net.{ URI, URISyntaxException } + + // name#fragment is OK, but otherwise fragile + def uri(name: String): URI = + try new URI(name) // new URI("jfo:" + name) + catch { case _: URISyntaxException => new URI("dummy") } def inputNamed(name: String): Try[ByteAry] = (managed find (_._1 == name)).get._2 def managedFile(name: String, kind: Kind) = kind match { @@ -379,19 +388,19 @@ class JavapClass( def showable(raw: Boolean, target: String): Showable = showWithPreamble(raw, target, reporter.reportable(raw)) // eventually, use the tool interface - def task(options: Seq[String], claases: Seq[String], inputs: Seq[Input]): Task = { + def task(options: Seq[String], classes: Seq[String], inputs: Seq[Input]): Task = { //ServiceLoader.load(classOf[javax.tools.DisassemblerTool]). - //getTask(writer, fileManager, reporter, options.asJava, claases.asJava) + //getTask(writer, fileManager, reporter, options.asJava, classes.asJava) import JavaConverters.asJavaIterableConverter - TaskCtor.newInstance(writer, fileManager(inputs), reporter, options.asJava, claases.asJava) + TaskCtor.newInstance(writer, fileManager(inputs), reporter, options.asJava, classes.asJava) .orFailed (throw new IllegalStateException) } // a result per input - private def applyOne(raw: Boolean, options: Seq[String], claas: String, inputs: Seq[Input]): Try[JpResult] = + private def applyOne(raw: Boolean, options: Seq[String], klass: String, inputs: Seq[Input]): Try[JpResult] = Try { - task(options, Seq(claas), inputs).call() + task(options, Seq(klass), inputs).call() } map { - case true => JpResult(showable(raw, claas)) + case true => JpResult(showable(raw, klass)) case _ => JpResult(reporter.reportable(raw)) } recoverWith { case e: java.lang.reflect.InvocationTargetException => e.getCause match { @@ -402,7 +411,7 @@ class JavapClass( reporter.clear() } override def apply(raw: Boolean, options: Seq[String])(inputs: Seq[Input]): List[JpResult] = (inputs map { - case (claas, Success(_)) => applyOne(raw, options, claas, inputs).get + case (klass, Success(_)) => applyOne(raw, options, klass, inputs).get case (_, Failure(e)) => JpResult(e.toString) }).toList orFailed List(noToolError) } @@ -534,6 +543,7 @@ class JavapClass( private def isTaskable(cl: ScalaClassLoader) = hasClass(cl, Tool) + /** Select the tool implementation for this platform. */ def apply() = if (isTaskable(loader)) new JavapTool7 else new JavapTool6 } } @@ -545,7 +555,8 @@ object JavapClass { intp: Option[IMain] = None ) = new JavapClass(loader, printWriter, intp) - val HashSplit = "(.*?)(?:#([^#]*))?".r + val HashSplit = "([^#]+)?(?:#(.+)?)?".r + // We enjoy flexibility in specifying either a fully-qualified class name com.acme.Widget // or a resource path com/acme/Widget.class; but not widget.out implicit class MaybeClassLike(val s: String) extends AnyVal { @@ -580,11 +591,11 @@ object JavapClass { /* only the file location from which the given class is loaded */ def locate(k: String): Option[Path] = { Try { - val claas = try cl loadClass k catch { + val klass = try cl loadClass k catch { case _: NoClassDefFoundError => null // let it snow } // cf ScalaClassLoader.originOfClass - claas.getProtectionDomain.getCodeSource.getLocation + klass.getProtectionDomain.getCodeSource.getLocation } match { case Success(null) => None case Success(loc) if loc.isFile => Some(Path(new JFile(loc.toURI))) From fadb21dc107b54e9d1a15abb626a36370bcd3501 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Fri, 23 May 2014 12:29:09 -0700 Subject: [PATCH 289/826] SI-8494 Javap filter includes specialized When filtering javap output, include specialized versions of methods. For anonfuns, in particular, the apply$sp is the method of interest. --- .../tools/nsc/interpreter/JavapClass.scala | 21 ++++++++++++------- 1 file changed, 13 insertions(+), 8 deletions(-) diff --git a/src/repl/scala/tools/nsc/interpreter/JavapClass.scala b/src/repl/scala/tools/nsc/interpreter/JavapClass.scala index f3ffea5a9b97..3cb6ba11c1dc 100644 --- a/src/repl/scala/tools/nsc/interpreter/JavapClass.scala +++ b/src/repl/scala/tools/nsc/interpreter/JavapClass.scala @@ -226,15 +226,20 @@ class JavapClass( def isOurMethod = { val lparen = line.lastIndexOf('(') val blank = line.lastIndexOf(' ', lparen) - (blank >= 0 && line.substring(blank+1, lparen) == pattern) - } - filtering = if (filtering) { - // next blank line terminates section - // for -public, next line is next method, more or less - line.trim.nonEmpty && !isAnyMethod - } else { - isAnyMethod && isOurMethod + if (blank < 0) false + else { + val method = line.substring(blank+1, lparen) + (method == pattern || ((method startsWith pattern+"$") && (method endsWith "$sp"))) + } } + filtering = + if (filtering) { + // next blank line terminates section + // for -public, next line is next method, more or less + line.trim.nonEmpty && !isAnyMethod + } else { + isAnyMethod && isOurMethod + } filtering } // do we output this line? From b3166d10b6cd5d61d1b10a4d308331d4a80aa411 Mon Sep 17 00:00:00 2001 From: clhodapp Date: Fri, 23 May 2014 23:13:49 -0500 Subject: [PATCH 290/826] SI-6678 Make currentMirror macro hygenic --- src/reflect/scala/reflect/runtime/package.scala | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/reflect/scala/reflect/runtime/package.scala b/src/reflect/scala/reflect/runtime/package.scala index 3c9bbccba38f..e240bed0a771 100644 --- a/src/reflect/scala/reflect/runtime/package.scala +++ b/src/reflect/scala/reflect/runtime/package.scala @@ -30,7 +30,8 @@ package runtime { import c.universe._ val runtimeClass = c.reifyEnclosingRuntimeClass if (runtimeClass.isEmpty) c.abort(c.enclosingPosition, "call site does not have an enclosing class") - val runtimeUniverse = Select(Select(Select(Ident(newTermName("scala")), newTermName("reflect")), newTermName("runtime")), newTermName("universe")) + val scalaPackage = Select(Ident(newTermName("_root_")), newTermName("scala")) + val runtimeUniverse = Select(Select(Select(scalaPackage, newTermName("reflect")), newTermName("runtime")), newTermName("universe")) val currentMirror = Apply(Select(runtimeUniverse, newTermName("runtimeMirror")), List(Select(runtimeClass, newTermName("getClassLoader")))) c.Expr[Nothing](currentMirror)(c.WeakTypeTag.Nothing) } From 60ef974982f6f9f641bee4eb9759f860709c6e5f Mon Sep 17 00:00:00 2001 From: Todd Vierling Date: Fri, 23 May 2014 11:07:12 -0400 Subject: [PATCH 291/826] To have effect, @deprecated needs to be an annotation. --- src/library/scala/collection/mutable/AVLTree.scala | 2 +- src/library/scala/concurrent/Lock.scala | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/library/scala/collection/mutable/AVLTree.scala b/src/library/scala/collection/mutable/AVLTree.scala index de09bb2040bd..cc2acb74d41c 100644 --- a/src/library/scala/collection/mutable/AVLTree.scala +++ b/src/library/scala/collection/mutable/AVLTree.scala @@ -14,8 +14,8 @@ package mutable * An immutable AVL Tree implementation formerly used by mutable.TreeSet * * @author Lucien Pereira - * @deprecated("AVLTree and its related classes are being removed from the standard library since they're not different enough from RedBlackTree to justify keeping them.", "2.11.0") */ +@deprecated("AVLTree and its related classes are being removed from the standard library since they're not different enough from RedBlackTree to justify keeping them.", "2.11.2") private[mutable] sealed trait AVLTree[+A] extends Serializable { def balance: Int diff --git a/src/library/scala/concurrent/Lock.scala b/src/library/scala/concurrent/Lock.scala index 1c00c0e91f1d..8d18da2d387f 100644 --- a/src/library/scala/concurrent/Lock.scala +++ b/src/library/scala/concurrent/Lock.scala @@ -14,8 +14,8 @@ package scala.concurrent * * @author Martin Odersky * @version 1.0, 10/03/2003 - * @deprecated("Use java.util.concurrent.locks.Lock", "2.11.0") */ +@deprecated("Use java.util.concurrent.locks.Lock", "2.11.2") class Lock { var available = true From bdf9195993caa3eee4f3be49428566323eaf4afd Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sat, 24 May 2014 20:42:27 +0200 Subject: [PATCH 292/826] SI-8617 Avoid rangepos crash for OptManifest materializer The tree to create a `NoManifest` was unpositioned. --- .../scala/tools/nsc/typechecker/Implicits.scala | 2 +- test/files/pos/t8617.flags | 1 + test/files/pos/t8617.scala | 10 ++++++++++ 3 files changed, 12 insertions(+), 1 deletion(-) create mode 100644 test/files/pos/t8617.flags create mode 100644 test/files/pos/t8617.scala diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index d87090fa465c..73c3e6f0169e 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -1306,7 +1306,7 @@ trait Implicits { } def wrapResult(tree: Tree): SearchResult = - if (tree == EmptyTree) SearchFailure else new SearchResult(tree, EmptyTreeTypeSubstituter, Nil) + if (tree == EmptyTree) SearchFailure else new SearchResult(atPos(pos.focus)(tree), EmptyTreeTypeSubstituter, Nil) /** Materializes implicits of predefined types (currently, manifests and tags). * Will be replaced by implicit macros once we fix them. diff --git a/test/files/pos/t8617.flags b/test/files/pos/t8617.flags new file mode 100644 index 000000000000..281f0a10cdc3 --- /dev/null +++ b/test/files/pos/t8617.flags @@ -0,0 +1 @@ +-Yrangepos diff --git a/test/files/pos/t8617.scala b/test/files/pos/t8617.scala new file mode 100644 index 000000000000..fc825bbcbadd --- /dev/null +++ b/test/files/pos/t8617.scala @@ -0,0 +1,10 @@ +object Test { + def foo[A] = implicitly[OptManifest[A]] // was "unpositioned tree" under -Yrangepos + + // These did not crash, but testing for good measure. + implicitly[OptManifest[String]] + implicitly[Manifest[String]] + + implicitly[reflect.ClassTag[String]] + implicitly[reflect.runtime.universe.TypeTag[String]] +} From 9fc098dd0dcf1825ec55501716b4f2a0a6d197ae Mon Sep 17 00:00:00 2001 From: Stephen Compall Date: Sat, 24 May 2014 17:31:19 -0400 Subject: [PATCH 293/826] SI-8346: Rebuild invariant sets in #toSet, avoiding CCE. SI-3953 caused several types of sets' operations to trivially throw `ClassCastException` after using inherited covariant #toSet method, by doing an unchecked cast that is only safe for intrinsically covariant set data structures like `HashSet`, but totally unsafe for others like `TreeSet` or `Enumeration.ValueSet`. This change moves the cast to the leaves of the class hierarchy where that is safe, and incidentally undeprecates overriding Set#toSet. --- .../scala/collection/immutable/HashSet.scala | 7 ++++ .../scala/collection/immutable/ListSet.scala | 7 ++++ .../scala/collection/immutable/Set.scala | 16 +++++---- test/files/run/t8346.check | 6 ++++ test/files/run/t8346.scala | 34 +++++++++++++++++++ 5 files changed, 64 insertions(+), 6 deletions(-) create mode 100644 test/files/run/t8346.check create mode 100644 test/files/run/t8346.scala diff --git a/src/library/scala/collection/immutable/HashSet.scala b/src/library/scala/collection/immutable/HashSet.scala index 726937efd963..e4b7371ed49d 100644 --- a/src/library/scala/collection/immutable/HashSet.scala +++ b/src/library/scala/collection/immutable/HashSet.scala @@ -162,6 +162,13 @@ class HashSet[A] extends AbstractSet[A] def - (e: A): HashSet[A] = nullToEmpty(removed0(e, computeHash(e), 0)) + /** Returns this $coll as an immutable set. + * + * A new set will not be built; lazy collections will stay lazy. + */ + @deprecatedOverriding("Immutable sets should do nothing on toSet but return themselves cast as a Set.", "2.11.0") + override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set[B]] + override def filter(p: A => Boolean) = { val buffer = new Array[HashSet[A]](bufferSize(size)) nullToEmpty(filter0(p, false, 0, buffer, 0)) diff --git a/src/library/scala/collection/immutable/ListSet.scala b/src/library/scala/collection/immutable/ListSet.scala index 1bb07eb02d5e..89d1a9640ed3 100644 --- a/src/library/scala/collection/immutable/ListSet.scala +++ b/src/library/scala/collection/immutable/ListSet.scala @@ -138,6 +138,13 @@ class ListSet[A] extends AbstractSet[A] override def stringPrefix = "ListSet" + /** Returns this $coll as an immutable set. + * + * A new set will not be built; lazy collections will stay lazy. + */ + @deprecatedOverriding("Immutable sets should do nothing on toSet but return themselves cast as a Set.", "2.11.0") + override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set[B]] + /** Represents an entry in the `ListSet`. */ protected class Node(override val head: A) extends ListSet[A] with Serializable { diff --git a/src/library/scala/collection/immutable/Set.scala b/src/library/scala/collection/immutable/Set.scala index 0fbf7942d426..7725ad9ee337 100644 --- a/src/library/scala/collection/immutable/Set.scala +++ b/src/library/scala/collection/immutable/Set.scala @@ -35,12 +35,7 @@ trait Set[A] extends Iterable[A] override def companion: GenericCompanion[Set] = Set - /** Returns this $coll as an immutable map. - * - * A new map will not be built; lazy collections will stay lazy. - */ - @deprecatedOverriding("Immutable sets should do nothing on toSet but return themselves cast as a Set.", "2.11.0") - override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set[B]] + override def toSet[B >: A]: Set[B] = to[({type l[a] = immutable.Set[B]})#l] // for bincompat; remove in dev override def seq: Set[A] = this protected override def parCombiner = ParSet.newCombiner[A] // if `immutable.SetLike` gets introduced, please move this there! @@ -62,6 +57,7 @@ object Set extends ImmutableSetFactory[Set] { def - (elem: Any): Set[Any] = this def iterator: Iterator[Any] = Iterator.empty override def foreach[U](f: Any => U): Unit = {} + override def toSet[B >: Any]: Set[B] = this.asInstanceOf[Set[B]] } private[collection] def emptyInstance: Set[Any] = EmptySet @@ -92,6 +88,8 @@ object Set extends ImmutableSetFactory[Set] { if (f(elem1)) Some(elem1) else None } + @deprecatedOverriding("Immutable sets should do nothing on toSet but return themselves cast as a Set.", "2.11.0") + override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set[B]] } /** An optimized representation for immutable sets of size 2 */ @@ -123,6 +121,8 @@ object Set extends ImmutableSetFactory[Set] { else if (f(elem2)) Some(elem2) else None } + @deprecatedOverriding("Immutable sets should do nothing on toSet but return themselves cast as a Set.", "2.11.0") + override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set[B]] } /** An optimized representation for immutable sets of size 3 */ @@ -156,6 +156,8 @@ object Set extends ImmutableSetFactory[Set] { else if (f(elem3)) Some(elem3) else None } + @deprecatedOverriding("Immutable sets should do nothing on toSet but return themselves cast as a Set.", "2.11.0") + override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set[B]] } /** An optimized representation for immutable sets of size 4 */ @@ -191,6 +193,8 @@ object Set extends ImmutableSetFactory[Set] { else if (f(elem4)) Some(elem4) else None } + @deprecatedOverriding("Immutable sets should do nothing on toSet but return themselves cast as a Set.", "2.11.0") + override def toSet[B >: A]: Set[B] = this.asInstanceOf[Set[B]] } } diff --git a/test/files/run/t8346.check b/test/files/run/t8346.check new file mode 100644 index 000000000000..1ba5c31abe42 --- /dev/null +++ b/test/files/run/t8346.check @@ -0,0 +1,6 @@ +BitSet: List(invariant, invariant, invariant, invariant) +HashSet: List(covariant (true), covariant (true), covariant (true), covariant (true)) +ListSet: List(covariant (true), covariant (true), covariant (true), covariant (true)) +SortedSet: List(invariant, invariant, invariant, invariant) +TreeSet: List(invariant, invariant, invariant, invariant) +ValueSet: invariant diff --git a/test/files/run/t8346.scala b/test/files/run/t8346.scala new file mode 100644 index 000000000000..5f3df841749d --- /dev/null +++ b/test/files/run/t8346.scala @@ -0,0 +1,34 @@ +object Test extends App { + import reflect.ClassTag + + object SomeEnum extends Enumeration { + val one, two, three, four = Value + } + + def sctor[A <: Set[Int]](f: Int => A)(implicit A: ClassTag[A]) + : (String, Int => Set[Int]) = + (A.runtimeClass.getSimpleName, f) + + val inits: Seq[(String, Int => Set[Int])] = { + import collection.immutable.{Seq => _, _} + Seq(sctor(BitSet(_)), + sctor(HashSet(_)), + sctor(ListSet(_)), + sctor(SortedSet(_)), + sctor(TreeSet(_))) + } + + def sVarInfo[A](sa: Set[A]): String = { + val saa = sa.toSet[Any] + if (sa eq saa) s"""covariant (${(saa + "hi") contains "hi"})""" + else "invariant" + } + + inits foreach {case (name, singleton) => + print(s"${name}: ") + val one = singleton(1) + println(Seq(2,3,4).scanLeft(one)(_ + _) map sVarInfo toList) + } + + println(s"ValueSet: ${sVarInfo(SomeEnum.values)}") +} From a6714f8fee2f8df9bc9d4760ed4c0c799f4f2c11 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Wed, 21 May 2014 10:25:21 +0200 Subject: [PATCH 294/826] Eliminate some N^2 performance in type checking Where N is the number of members of the enclosing package. Double definition errors for top level classes/objects are issued elsewhere, as demonstrated by the enclosed test. So we can omit the call to `checkNoDoubleDefs` in this content. We can't omit the call to `addSynthetics` for package class owners (case- and value-class synthetic companions are added here), but we can make the process cheaper by moving the expensive-but-usually-true call to `shouldAdd`. Here's an example of the improvement. % rm -rf /tmp/pkg; (for i in {1..50}; do for j in {1..100}; do echo "package pkg { class A_${i}_${j}___(val a: Int, val b: Int) }"; done; done) > sandbox/A1.scala && time scalac-hash v2.11.0 -Ybackend:GenASM -J-Xmx1G -J-XX:MaxPermSize=400M -d /tmp sandbox/A1.scala; real 0m49.762s user 1m12.376s sys 0m2.371s % rm -rf /tmp/pkg; (for i in {1..50}; do for j in {1..100}; do echo "package pkg { class A_${i}_${j}___(val a: Int, val b: Int) }"; done; done) > sandbox/A1.scala && time qbin/scalac -Ybackend:GenASM -J-Xmx1G -J-XX:MaxPermSize=400M -d /tmp sandbox/A1.scala; real 0m35.662s user 0m58.275s sys 0m2.355s We've still got another source of pathological performance in creating nested scopes that I'll fix in the next commit. --- src/compiler/scala/tools/nsc/typechecker/Typers.scala | 11 +++++++---- test/files/neg/double-def-top-level.check | 7 +++++++ test/files/neg/double-def-top-level/A_1.scala | 4 ++++ test/files/neg/double-def-top-level/B_2.scala | 2 ++ test/files/neg/double-def-top-level/C_3.scala | 2 ++ test/files/neg/double-def-top-level/D_3.scala | 2 ++ 6 files changed, 24 insertions(+), 4 deletions(-) create mode 100644 test/files/neg/double-def-top-level.check create mode 100644 test/files/neg/double-def-top-level/A_1.scala create mode 100644 test/files/neg/double-def-top-level/B_2.scala create mode 100644 test/files/neg/double-def-top-level/C_3.scala create mode 100644 test/files/neg/double-def-top-level/D_3.scala diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 9fe693ce2ab0..66b1c2d87a3c 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -3022,7 +3022,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper || (looker.hasAccessorFlag && !accessed.hasAccessorFlag && accessed.isPrivate) ) - def checkNoDoubleDefs(stats: List[Tree]): Unit = { + def checkNoDoubleDefs: Unit = { val scope = if (inBlock) context.scope else context.owner.info.decls var e = scope.elems while ((e ne null) && e.owner == scope) { @@ -3057,8 +3057,8 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper // the corresponding synthetics to the package class, only to the package object class. def shouldAdd(sym: Symbol) = inBlock || !context.isInPackageObject(sym, context.owner) - for (sym <- scope if shouldAdd(sym)) - for (tree <- context.unit.synthetics get sym) { + for (sym <- scope) + for (tree <- context.unit.synthetics get sym if shouldAdd(sym)) { // OPT: shouldAdd is usually true. Call it here, rather than in the outer loop newStats += typedStat(tree) // might add even more synthetics to the scope context.unit.synthetics -= sym } @@ -3104,7 +3104,10 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper val stats1 = stats mapConserve typedStat if (phase.erasedTypes) stats1 else { - checkNoDoubleDefs(stats1) + // As packages are open, it doesn't make sense to check double definitions here. Furthermore, + // it is expensive if the package is large. Instead, such double defininitions are checked in `Namers.enterInScope` + if (!context.owner.isPackageClass) + checkNoDoubleDefs addSynthetics(stats1) } } diff --git a/test/files/neg/double-def-top-level.check b/test/files/neg/double-def-top-level.check new file mode 100644 index 000000000000..85b16e81e5fa --- /dev/null +++ b/test/files/neg/double-def-top-level.check @@ -0,0 +1,7 @@ +D_3.scala:1: error: C is already defined as class C +class C + ^ +D_3.scala:2: error: O is already defined as object O +object O + ^ +two errors found diff --git a/test/files/neg/double-def-top-level/A_1.scala b/test/files/neg/double-def-top-level/A_1.scala new file mode 100644 index 000000000000..c3d68d9d05fb --- /dev/null +++ b/test/files/neg/double-def-top-level/A_1.scala @@ -0,0 +1,4 @@ +package p + +class C +object O diff --git a/test/files/neg/double-def-top-level/B_2.scala b/test/files/neg/double-def-top-level/B_2.scala new file mode 100644 index 000000000000..c328e8c964a9 --- /dev/null +++ b/test/files/neg/double-def-top-level/B_2.scala @@ -0,0 +1,2 @@ +class C /* noerror */ +object O /* noerror */ \ No newline at end of file diff --git a/test/files/neg/double-def-top-level/C_3.scala b/test/files/neg/double-def-top-level/C_3.scala new file mode 100644 index 000000000000..e1c327c15aa6 --- /dev/null +++ b/test/files/neg/double-def-top-level/C_3.scala @@ -0,0 +1,2 @@ +class C +object O \ No newline at end of file diff --git a/test/files/neg/double-def-top-level/D_3.scala b/test/files/neg/double-def-top-level/D_3.scala new file mode 100644 index 000000000000..518e0d1c54c7 --- /dev/null +++ b/test/files/neg/double-def-top-level/D_3.scala @@ -0,0 +1,2 @@ +class C +object O From 4aa10a1f6fa803159638355ef9c2aa968eb16556 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Wed, 21 May 2014 10:40:13 +0200 Subject: [PATCH 295/826] Optimize nested scope creation We can copy the hash table from the parent scope, rather than constructing it from scratch. This takes us to: % rm -rf /tmp/pkg; (for i in {1..50}; do for j in {1..100}; do echo "package pkg { class A_${i}_${j}___(val a: Int, val b: Int) }"; done; done) > sandbox/A1.scala && time qbin/scalac -Ybackend:GenASM -J-Xmx1G -J-XX:MaxPermSize=400M -d /tmp sandbox/A1.scala; real 0m19.639s // head~1 was 0m35.662s user 0m41.683s // head~1 was 0m58.275s sys 0m1.886s In more detail, this commit: - Removes the unused `fingerprint` constructor parameter from scopes. This is a remnant from a previous optimization attempt - Leave only one constructor on Scope which creates an empty scope - Update the factory method, `newNestedScope`, to copy the hash table from the parent if it exists. We can rely on the invariant that `outer.hashTable != null || outer.size < MIN_HASH)`, so we don't need `if (size >= MIN_HASH) createHash()` anymore. This used to be needed in `Scope#`, which accepted an aribitrary `initElems: ScopeEntry`. - Update subclasses and factories of `Scope` in runtime reflection to accomodate the change. Pleasingly, we could actually remove the override for `newNestedScope`. - Unit tests the functionality I'm touching --- bincompat-backward.whitelist.conf | 4 ++ bincompat-forward.whitelist.conf | 4 ++ .../scala/reflect/internal/Scopes.scala | 24 ++++----- .../scala/reflect/runtime/SymbolLoaders.scala | 2 +- .../reflect/runtime/SynchronizedOps.scala | 3 +- .../scala/reflect/internal/ScopeTest.scala | 54 +++++++++++++++++++ 6 files changed, 76 insertions(+), 15 deletions(-) create mode 100644 test/junit/scala/reflect/internal/ScopeTest.scala diff --git a/bincompat-backward.whitelist.conf b/bincompat-backward.whitelist.conf index 703c5add42ce..ffacbf044283 100644 --- a/bincompat-backward.whitelist.conf +++ b/bincompat-backward.whitelist.conf @@ -181,6 +181,10 @@ filter { { matchName="scala.reflect.api.Internals#ReificationSupportApi.SyntacticExistentialType" problemName=MissingMethodProblem + }, + { + matchName="scala.reflect.runtime.SynchronizedOps.newNestedScope" + problemName=MissingMethodProblem } ] } diff --git a/bincompat-forward.whitelist.conf b/bincompat-forward.whitelist.conf index ca8f7468eb8e..3cd985aeae03 100644 --- a/bincompat-forward.whitelist.conf +++ b/bincompat-forward.whitelist.conf @@ -230,6 +230,10 @@ filter { { matchName="scala.reflect.runtime.JavaMirrors#JavaMirror.scala$reflect$runtime$JavaMirrors$JavaMirror$$followStatic" problemName=MissingMethodProblem + }, + { + matchName="scala.reflect.runtime.SynchronizedOps.newNestedScope" + problemName=MissingMethodProblem } ] } diff --git a/src/reflect/scala/reflect/internal/Scopes.scala b/src/reflect/scala/reflect/internal/Scopes.scala index cf3f356daabd..103f885ad4a9 100644 --- a/src/reflect/scala/reflect/internal/Scopes.scala +++ b/src/reflect/scala/reflect/internal/Scopes.scala @@ -48,22 +48,17 @@ trait Scopes extends api.Scopes { self: SymbolTable => * This is necessary because when run from reflection every scope needs to have a * SynchronizedScope as mixin. */ - class Scope protected[Scopes] (initElems: ScopeEntry = null, initFingerPrints: Long = 0L) extends ScopeApi with MemberScopeApi { + class Scope protected[Scopes]() extends ScopeApi with MemberScopeApi { - protected[Scopes] def this(base: Scope) = { - this(base.elems) - nestinglevel = base.nestinglevel + 1 - } - - private[scala] var elems: ScopeEntry = initElems + private[scala] var elems: ScopeEntry = _ /** The number of times this scope is nested in another */ - private var nestinglevel = 0 + private[Scopes] var nestinglevel = 0 /** the hash table */ - private var hashtable: Array[ScopeEntry] = null + private[Scopes] var hashtable: Array[ScopeEntry] = null /** a cache for all elements, to be used by symbol iterator. */ @@ -84,8 +79,6 @@ trait Scopes extends api.Scopes { self: SymbolTable => */ private val MIN_HASH = 8 - if (size >= MIN_HASH) createHash() - /** Returns a new scope with the same content as this one. */ def cloneScope: Scope = newScopeWith(this.toList: _*) @@ -435,7 +428,14 @@ trait Scopes extends api.Scopes { self: SymbolTable => } /** Create a new scope nested in another one with which it shares its elements */ - def newNestedScope(outer: Scope): Scope = new Scope(outer) + final def newNestedScope(outer: Scope): Scope = { + val nested = newScope // not `new Scope`, we must allow the runtime reflection universe to mixin SynchronizedScopes! + nested.elems = outer.elems + nested.nestinglevel = outer.nestinglevel + 1 + if (outer.hashtable ne null) + nested.hashtable = java.util.Arrays.copyOf(outer.hashtable, outer.hashtable.length) + nested + } /** Create a new scope with given initial elements */ def newScopeWith(elems: Symbol*): Scope = { diff --git a/src/reflect/scala/reflect/runtime/SymbolLoaders.scala b/src/reflect/scala/reflect/runtime/SymbolLoaders.scala index c56bc28d9081..7ba68b873341 100644 --- a/src/reflect/scala/reflect/runtime/SymbolLoaders.scala +++ b/src/reflect/scala/reflect/runtime/SymbolLoaders.scala @@ -91,7 +91,7 @@ private[reflect] trait SymbolLoaders { self: SymbolTable => // // Short of significantly changing SymbolLoaders I see no other way than just // to slap a global lock on materialization in runtime reflection. - class PackageScope(pkgClass: Symbol) extends Scope(initFingerPrints = -1L) // disable fingerprinting as we do not know entries beforehand + class PackageScope(pkgClass: Symbol) extends Scope with SynchronizedScope { assert(pkgClass.isType) diff --git a/src/reflect/scala/reflect/runtime/SynchronizedOps.scala b/src/reflect/scala/reflect/runtime/SynchronizedOps.scala index c90901410a35..4a8585d61603 100644 --- a/src/reflect/scala/reflect/runtime/SynchronizedOps.scala +++ b/src/reflect/scala/reflect/runtime/SynchronizedOps.scala @@ -37,8 +37,7 @@ private[reflect] trait SynchronizedOps extends internal.SymbolTable // Scopes - override def newScope = new Scope() with SynchronizedScope - override def newNestedScope(outer: Scope): Scope = new Scope(outer) with SynchronizedScope + override def newScope = new Scope with SynchronizedScope trait SynchronizedScope extends Scope { // we can keep this lock fine-grained, because methods of Scope don't do anything extraordinary, which makes deadlocks impossible diff --git a/test/junit/scala/reflect/internal/ScopeTest.scala b/test/junit/scala/reflect/internal/ScopeTest.scala new file mode 100644 index 000000000000..51666201892f --- /dev/null +++ b/test/junit/scala/reflect/internal/ScopeTest.scala @@ -0,0 +1,54 @@ +package symtab + +import scala.tools.nsc.symtab + +import org.junit.Assert._ +import org.junit.Test +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 + +import scala.tools.testing.AssertUtil.assertThrows +import scala.tools.nsc.symtab.SymbolTableForUnitTesting + +@RunWith(classOf[JUnit4]) +class ScopeTest { + object symbolTable extends SymbolTableForUnitTesting + + import symbolTable._ + + @Test + def testNestedScopeSmall(): Unit = testNestedScope(0) + @Test + def testNestedScopeLarge(): Unit = testNestedScope(64) // exceeding MIN_HASH + + private def testNestedScope(initSize: Int) { + def sym(termName: String): Symbol = NoSymbol.newValue(TermName(termName)) + val foo = sym("foo") + val bar = sym("bar") + + val outerElems = List.tabulate(initSize)(i => sym(i.toString)) + val outer = newScopeWith(outerElems ++ List(foo, bar) : _*) + assertTrue(outer.containsName(foo.name)) + assertTrue(outer.containsName(bar.name)) + + val baz = sym("baz") + val nested = newNestedScope(outer) + + // Entries from the outer scope are entered in the nested. + assertTrue(outer.containsName(foo.name)) + assertTrue(outer.containsName(bar.name)) + + // Nested scopes structurally share ScopeEntry-s with the outer. + assertSame(outer.lookupEntry(foo.name), nested.lookupEntry(foo.name)) + nested.enter(baz) + + // Symbols entered in the nested scope aren't visible in the outer. + assertTrue(nested.containsName(baz.name)) + assertTrue(!outer.containsName(baz.name)) + + // Unlinking a symbol in the inner scope doesn't modify the outer + nested.unlink(bar) + assert(!nested.containsName(bar.name)) + assert(outer.containsName(bar.name)) + } +} From 748ab3044b681ee13d98dd48423d355d3f594b83 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Fri, 23 May 2014 17:51:16 +0200 Subject: [PATCH 296/826] Fast path in Namer for methods without defaults Either direct defaults, or directly inherited. The avoids `addDefaultGetters` in most cases, and the expensive duplication of trees therein. --- src/compiler/scala/tools/nsc/typechecker/Namers.scala | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index 4382a2c6f77f..205383d25a92 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -1177,7 +1177,13 @@ trait Namers extends MethodSynthesis { } } - addDefaultGetters(meth, ddef, vparamss, tparams, overriddenSymbol(methResTp)) + val overridden = { + val isConstr = meth.isConstructor + if (isConstr || !methOwner.isClass) NoSymbol else overriddenSymbol(methResTp) + } + val hasDefaults = mexists(vparamss)(_.symbol.hasDefault) || mexists(overridden.paramss)(_.hasDefault) + if (hasDefaults) + addDefaultGetters(meth, ddef, vparamss, tparams, overridden) // fast track macros, i.e. macros defined inside the compiler, are hardcoded // hence we make use of that and let them have whatever right-hand side they need @@ -1219,7 +1225,7 @@ trait Namers extends MethodSynthesis { * typechecked, the corresponding param would not yet have the "defaultparam" * flag. */ - private def addDefaultGetters(meth: Symbol, ddef: DefDef, vparamss: List[List[ValDef]], tparams: List[TypeDef], overriddenSymbol: => Symbol) { + private def addDefaultGetters(meth: Symbol, ddef: DefDef, vparamss: List[List[ValDef]], tparams: List[TypeDef], overridden: Symbol) { val DefDef(_, _, rtparams0, rvparamss0, _, _) = resetAttrs(ddef.duplicate) // having defs here is important to make sure that there's no sneaky tree sharing // in methods with multiple default parameters @@ -1227,7 +1233,6 @@ trait Namers extends MethodSynthesis { def rvparamss = rvparamss0.map(_.map(_.duplicate)) val methOwner = meth.owner val isConstr = meth.isConstructor - val overridden = if (isConstr || !methOwner.isClass) NoSymbol else overriddenSymbol val overrides = overridden != NoSymbol && !overridden.isOverloaded // value parameters of the base class (whose defaults might be overridden) var baseParamss = (vparamss, overridden.tpe.paramss) match { From 33446bd6f311a2bd5e565382836327fe5d337df7 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Thu, 15 May 2014 15:21:49 +0200 Subject: [PATCH 297/826] Optimize enforcement of dependent method type restrictions - No need to check the result type, as dependent method types are now enabled unconditionally. - This also means we can only need to check methods with two or more parameter lists. --- src/compiler/scala/tools/nsc/typechecker/Namers.scala | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index 205383d25a92..099031d536fa 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -1040,10 +1040,10 @@ trait Namers extends MethodSynthesis { * so the resulting type is a valid external method type, it does not contain (references to) skolems. */ def thisMethodType(restpe: Type) = { - val checkDependencies = new DependentTypeChecker(context)(this) - checkDependencies check vparamSymss - // DEPMETTODO: check not needed when they become on by default - checkDependencies(restpe) + if (vparamSymss.lengthCompare(0) > 0) { // OPT fast path for methods of 0-1 parameter lists + val checkDependencies = new DependentTypeChecker(context)(this) + checkDependencies check vparamSymss + } val makeMethodType = (vparams: List[Symbol], restpe: Type) => { // TODODEPMET: check that we actually don't need to do anything here @@ -1750,7 +1750,6 @@ trait Namers extends MethodSynthesis { for (p <- vps) this(p.info) // can only refer to symbols in earlier parameter sections - // (if the extension is enabled) okParams ++= vps } } From 7ecd98bca6a4aa28de4e406bd27712007768647a Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 27 May 2014 12:24:26 +0300 Subject: [PATCH 298/826] SI-8625 fix unreachability analysis for boolean expressions --- .../scala/tools/nsc/backend/icode/GenICode.scala | 13 ++++++++++--- test/files/pos/t8625.scala | 5 +++++ 2 files changed, 15 insertions(+), 3 deletions(-) create mode 100644 test/files/pos/t8625.scala diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala index 0da66d43f78c..0ad3c2c76bbb 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala @@ -1424,11 +1424,18 @@ abstract class GenICode extends SubComponent { def genZandOrZor(and: Boolean): Boolean = { val ctxInterm = ctx.newBlock() - val branchesReachable = if (and) genCond(lhs, ctx, ctxInterm, elseCtx) + val lhsBranchesReachable = if (and) genCond(lhs, ctx, ctxInterm, elseCtx) else genCond(lhs, ctx, thenCtx, ctxInterm) - ctxInterm.bb killUnless branchesReachable + // If lhs is known to throw, we can kill the just created ctxInterm. + ctxInterm.bb killUnless lhsBranchesReachable - genCond(rhs, ctxInterm, thenCtx, elseCtx) + val rhsBranchesReachable = genCond(rhs, ctxInterm, thenCtx, elseCtx) + + // Reachable means "it does not always throw", i.e. "it might not throw". + // In an expression (a && b) or (a || b), the b branch might not be evaluated. + // Such an expression is therefore known to throw only if both expressions throw. Or, + // successors are reachable if either of the two is reachable (SI-8625). + lhsBranchesReachable || rhsBranchesReachable } def genRefEq(isEq: Boolean) = { val f = genEqEqPrimitive(lhs, rhs, ctx) _ diff --git a/test/files/pos/t8625.scala b/test/files/pos/t8625.scala new file mode 100644 index 000000000000..95c4b0dbcd77 --- /dev/null +++ b/test/files/pos/t8625.scala @@ -0,0 +1,5 @@ +object Test { + def f1(a: Boolean, b: Boolean) = (a || ???) && (b || ???) + def f2(a: Boolean, b: Boolean) = (a || ???) && b + def f3(a: Boolean, b: Boolean) = (a && ???) || b +} From d4f664c98364858c319b599caa1cdbb68030440a Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Tue, 27 May 2014 12:06:56 -0700 Subject: [PATCH 299/826] SI-8475 GroupedIterator is also lazy when padded This is the related case which dnlgtm in the previous fix. The old code seems to be tilting for laziness, but we have to fill the buffer with the current group anyway, so there is no reason to be coy about calling ArrayBuffer.length. --- src/library/scala/collection/Iterator.scala | 13 +++++++------ test/junit/scala/collection/IteratorTest.scala | 8 ++++++++ 2 files changed, 15 insertions(+), 6 deletions(-) diff --git a/src/library/scala/collection/Iterator.scala b/src/library/scala/collection/Iterator.scala index e321a6adbad8..f6f46e158f98 100644 --- a/src/library/scala/collection/Iterator.scala +++ b/src/library/scala/collection/Iterator.scala @@ -922,6 +922,9 @@ trait Iterator[+A] extends TraversableOnce[A] { /** For reasons which remain to be determined, calling * self.take(n).toSeq cause an infinite loop, so we have * a slight variation on take for local usage. + * NB: self.take.toSeq is slice.toStream, lazily built on self, + * so a subsequent self.hasNext would not test self after the + * group was consumed. */ private def takeDestructively(size: Int): Seq[A] = { val buf = new ArrayBuffer[A] @@ -945,12 +948,10 @@ trait Iterator[+A] extends TraversableOnce[A] { // so the rest of the code can be oblivious val xs: Seq[B] = { val res = takeDestructively(count) - // extra checks so we don't calculate length unless there's reason - if (pad.isDefined && !self.hasNext) { - val shortBy = count - res.length - if (shortBy > 0) res ++ padding(shortBy) else res - } - else res + // was: extra checks so we don't calculate length unless there's reason + // but since we took the group eagerly, just use the fast length + val shortBy = count - res.length + if (shortBy > 0 && pad.isDefined) res ++ padding(shortBy) else res } lazy val len = xs.length lazy val incomplete = len < count diff --git a/test/junit/scala/collection/IteratorTest.scala b/test/junit/scala/collection/IteratorTest.scala index cb7cbb40bc2e..b7a9805c9fe4 100644 --- a/test/junit/scala/collection/IteratorTest.scala +++ b/test/junit/scala/collection/IteratorTest.scala @@ -17,4 +17,12 @@ class IteratorTest { slidingIt.next assertEquals("Counter should be one, that means we didn't look further than needed", 1, counter) } + + @Test def groupedIteratorIsLazyWhenPadded(): Unit = { + var counter = 0 + def it = new Iterator[Int] { var i = 0 ; def hasNext = { counter = i; true } ; def next = { i += 1; i } } + val slidingIt = it sliding 2 withPadding -1 + slidingIt.next + assertEquals("Counter should be one, that means we didn't look further than needed", 1, counter) + } } From 5277fb4d69714b52a9c43fd6ac439e6d16d7a3e9 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Tue, 27 May 2014 12:55:13 -0700 Subject: [PATCH 300/826] SI-8630 lineToString no longer long by one at eof One more EOL crasher, or lack-of-EOL crasher, when the text is at EOF. It was not caught by the last round of excellent and thorough tests because ``` // If non-whitespace tokens run all the way up to EOF, // positions go wrong because the correct end of the last // token cannot be used as an index into the char array. // The least painful way to address this was to add a // newline to the array. ``` --- src/reflect/scala/reflect/internal/util/SourceFile.scala | 2 +- test/files/neg/t8630.check | 7 +++++++ test/files/neg/t8630.scala | 1 + .../junit/scala/reflect/internal/util/SourceFileTest.scala | 5 +++++ 4 files changed, 14 insertions(+), 1 deletion(-) create mode 100644 test/files/neg/t8630.check create mode 100644 test/files/neg/t8630.scala diff --git a/src/reflect/scala/reflect/internal/util/SourceFile.scala b/src/reflect/scala/reflect/internal/util/SourceFile.scala index 4fccad74ac61..a2642628a431 100644 --- a/src/reflect/scala/reflect/internal/util/SourceFile.scala +++ b/src/reflect/scala/reflect/internal/util/SourceFile.scala @@ -40,7 +40,7 @@ abstract class SourceFile { def lineToString(index: Int): String = { val start = lineToOffset(index) var end = start - while (!isEndOfLine(end) && end <= length) end += 1 + while (end < length && !isEndOfLine(end)) end += 1 new String(content, start, end - start) } diff --git a/test/files/neg/t8630.check b/test/files/neg/t8630.check new file mode 100644 index 000000000000..98b084b15333 --- /dev/null +++ b/test/files/neg/t8630.check @@ -0,0 +1,7 @@ +t8630.scala:1: error: '{' expected but 'abstract' found. +package bobsdelights abstract class Fruit( val name: String, val color: String ) object Fruits { object Apple extends Fruit("apple", "red") object Orange extends Fruit("orange", "orange") object Pear extends Fruit("pear", "yellowish") val menu = List(Apple, Orange, Pear) } + ^ +t8630.scala:1: error: '}' expected but eof found. +package bobsdelights abstract class Fruit( val name: String, val color: String ) object Fruits { object Apple extends Fruit("apple", "red") object Orange extends Fruit("orange", "orange") object Pear extends Fruit("pear", "yellowish") val menu = List(Apple, Orange, Pear) } + ^ +two errors found diff --git a/test/files/neg/t8630.scala b/test/files/neg/t8630.scala new file mode 100644 index 000000000000..ea2522745286 --- /dev/null +++ b/test/files/neg/t8630.scala @@ -0,0 +1 @@ +package bobsdelights abstract class Fruit( val name: String, val color: String ) object Fruits { object Apple extends Fruit("apple", "red") object Orange extends Fruit("orange", "orange") object Pear extends Fruit("pear", "yellowish") val menu = List(Apple, Orange, Pear) } \ No newline at end of file diff --git a/test/junit/scala/reflect/internal/util/SourceFileTest.scala b/test/junit/scala/reflect/internal/util/SourceFileTest.scala index 903e705ba271..cad23eba1454 100644 --- a/test/junit/scala/reflect/internal/util/SourceFileTest.scala +++ b/test/junit/scala/reflect/internal/util/SourceFileTest.scala @@ -17,6 +17,11 @@ class SourceFileTest { assertFalse(file.isEndOfLine(Int.MaxValue)) } + @Test def si8630_lineToString(): Unit = { + val code = "abc " + assertEquals(code, new BatchSourceFile("", code).lineToString(0)) + } + @Test def si8205_lineToString(): Unit = { assertEquals("", lineContentOf("", 0)) From 2cee3b6aa29efa49c840ef663ec158b83704d945 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Wed, 28 May 2014 16:14:03 +0200 Subject: [PATCH 301/826] Include scalap in the distro. --- src/build/maven/scala-dist-pom.xml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/build/maven/scala-dist-pom.xml b/src/build/maven/scala-dist-pom.xml index 22a24dea2152..9477e1428538 100644 --- a/src/build/maven/scala-dist-pom.xml +++ b/src/build/maven/scala-dist-pom.xml @@ -39,6 +39,11 @@ scala-compiler @VERSION@ + + org.scala-lang + scalap + @VERSION@ + org.scala-lang.plugins From c8f8782f6a07d1cc3297f22b1798f8e2d562db88 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Wed, 28 May 2014 13:04:24 -0700 Subject: [PATCH 302/826] SI-8503 Clean up interpolation of help message We have interpolation now. This commit also moves an extra blank line from the end to the middle of the message. --- .../tools/nsc/GenericRunnerCommand.scala | 22 +++++++++---------- 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/src/compiler/scala/tools/nsc/GenericRunnerCommand.scala b/src/compiler/scala/tools/nsc/GenericRunnerCommand.scala index e71022228580..253f18dec6de 100644 --- a/src/compiler/scala/tools/nsc/GenericRunnerCommand.scala +++ b/src/compiler/scala/tools/nsc/GenericRunnerCommand.scala @@ -50,17 +50,16 @@ extends CompilerCommand(args, settings) { case Nil => AsRepl case hd :: _ => waysToRun find (_.name == settings.howtorun.value) getOrElse guessHowToRun(hd) } - private def interpolate(s: String) = s.trim.replaceAll("@cmd@", cmdName).replaceAll("@compileCmd@", compCmdName) + "\n" - def shortUsageMsg = interpolate(""" -Usage: @cmd@ [ ] - or @cmd@ -help + def shortUsageMsg = +s"""|Usage: $cmdName [ ] + | or $cmdName -help + | + |All options to $compCmdName (see $compCmdName -help) are also allowed. +""".stripMargin -All options to @compileCmd@ (see @compileCmd@ -help) are also allowed. -""") - - override def usageMsg = shortUsageMsg + interpolate(""" -The first given argument other than options to @cmd@ designates + override def usageMsg = f"""$shortUsageMsg +The first given argument other than options to $cmdName designates what to run. Runnable targets are: - a file containing scala source @@ -68,7 +67,7 @@ what to run. Runnable targets are: - a runnable jar file with a valid Main-Class attribute - or if no argument is given, the repl (interactive shell) is started -Options to @cmd@ which reach the java runtime: +Options to $cmdName which reach the java runtime: -Dname=prop passed directly to java to set system properties -J -J is stripped and passed to java as-is @@ -86,8 +85,7 @@ A file argument will be run as a scala script unless it contains only self-contained compilation units (classes and objects) and exactly one runnable main method. In that case the file will be compiled and the main method invoked. This provides a bridge between scripts and standard -scala source. - """) + "\n" +scala source.%n""" } object GenericRunnerCommand { From d28879042951015f0ef2d5263b7df264a13a8055 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Wed, 28 May 2014 21:46:53 +0200 Subject: [PATCH 303/826] SI-8596 Fix rangepos crasher with defaults, poly methods Regressed in SI-7915 / 3009a525b5 We should be deriving the position of the synthetic `Select` from `basefun1`, rather than `basefun`. In the new, enclosed test, the difference amounts to: new Container().typeParamAndDefaultArg[Any]() `------------ basefun1 --------------' `----------------- basefun ---------------' For monomorphic methods, these are one and the same, which is why `presentation/t7915` was working. I've extended that test to a polymorphic method to check that hyperlink resolution works. --- .../tools/nsc/typechecker/NamesDefaults.scala | 6 +++--- test/files/pos/t8596.flags | 1 + test/files/pos/t8596.scala | 7 +++++++ test/files/presentation/t7915.check | 20 +++++++++++++++++++ test/files/presentation/t7915/src/Foo.scala | 4 +++- 5 files changed, 34 insertions(+), 4 deletions(-) create mode 100644 test/files/pos/t8596.flags create mode 100644 test/files/pos/t8596.scala diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala index 70f2f41ec75b..307e17d97ab2 100644 --- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala +++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala @@ -175,9 +175,9 @@ trait NamesDefaults { self: Analyzer => // setSymbol below is important because the 'selected' function might be overloaded. by // assigning the correct method symbol, typedSelect will just assign the type. the reason // to still call 'typed' is to correctly infer singleton types, SI-5259. - val selectPos = - if(qual.pos.isRange && baseFun.pos.isRange) qual.pos.union(baseFun.pos).withStart(Math.min(qual.pos.end, baseFun.pos.end)) - else baseFun.pos + val selectPos = + if(qual.pos.isRange && baseFun1.pos.isRange) qual.pos.union(baseFun1.pos).withStart(Math.min(qual.pos.end, baseFun1.pos.end)) + else baseFun1.pos val f = blockTyper.typedOperator(Select(newQual, selected).setSymbol(baseFun1.symbol).setPos(selectPos)) if (funTargs.isEmpty) f else TypeApply(f, funTargs).setType(baseFun.tpe) diff --git a/test/files/pos/t8596.flags b/test/files/pos/t8596.flags new file mode 100644 index 000000000000..281f0a10cdc3 --- /dev/null +++ b/test/files/pos/t8596.flags @@ -0,0 +1 @@ +-Yrangepos diff --git a/test/files/pos/t8596.scala b/test/files/pos/t8596.scala new file mode 100644 index 000000000000..bfed58eadfc3 --- /dev/null +++ b/test/files/pos/t8596.scala @@ -0,0 +1,7 @@ +class TypeTreeObjects { + class Container { + def typeParamAndDefaultArg[C](name: String = ""): String = "" + } + // crashed under -Yrangepos + new Container().typeParamAndDefaultArg[Any]() +} diff --git a/test/files/presentation/t7915.check b/test/files/presentation/t7915.check index b18b4ddb55ac..0849aaa82b1b 100644 --- a/test/files/presentation/t7915.check +++ b/test/files/presentation/t7915.check @@ -9,3 +9,23 @@ askHyperlinkPos for `bar` at (7,22) Foo.scala ================================================================================ [response] found askHyperlinkPos for `bar` at (2,7) Foo.scala ================================================================================ + +askHyperlinkPos for `Bar` at (8,11) Foo.scala +================================================================================ +[response] found askHyperlinkPos for `Bar` at (1,7) Foo.scala +================================================================================ + +askHyperlinkPos for `baz` at (8,22) Foo.scala +================================================================================ +[response] found askHyperlinkPos for `baz` at (2,31) Foo.scala +================================================================================ + +askHyperlinkPos for `Bar` at (9,11) Foo.scala +================================================================================ +[response] found askHyperlinkPos for `Bar` at (1,7) Foo.scala +================================================================================ + +askHyperlinkPos for `baz` at (9,22) Foo.scala +================================================================================ +[response] found askHyperlinkPos for `baz` at (2,31) Foo.scala +================================================================================ diff --git a/test/files/presentation/t7915/src/Foo.scala b/test/files/presentation/t7915/src/Foo.scala index a4166ae5b411..5c9ca36a6e46 100644 --- a/test/files/presentation/t7915/src/Foo.scala +++ b/test/files/presentation/t7915/src/Foo.scala @@ -1,9 +1,11 @@ class Bar { - def bar(b: Int = 2) {} + def bar(b: Int = 2) {}; def baz[X](b: Int = 2) {} } class Foo { def foo() { new Bar/*#*/().bar/*#*/() + new Bar/*#*/().baz/*#*/[Any]() + new Bar/*#*/().baz/*#*/() } } From 56e6726c0cabb075b2135ef1a71054aaf7ea6fd0 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Wed, 28 May 2014 18:04:29 -0700 Subject: [PATCH 304/826] SI-8503 -version is info setting And the Scala runner exits with 0 for info settings. Producing the version string is consolidated. The compiler driver uses the default settings hook to short-circuit on -version. That's to avoid creating the compiler; really it should check shouldStopWithInfo first, as the runner does. --- .../scala/tools/nsc/CompilerCommand.scala | 11 +- src/compiler/scala/tools/nsc/Driver.scala | 21 ++- .../tools/nsc/GenericRunnerCommand.scala | 5 +- .../tools/nsc/settings/ScalaSettings.scala | 2 +- .../scala/tools/nsc/interactive/Main.scala | 7 +- src/library/scala/util/Properties.scala | 7 +- .../scala/tools/nsc/MainGenericRunner.scala | 128 +++++++++--------- 7 files changed, 93 insertions(+), 88 deletions(-) diff --git a/src/compiler/scala/tools/nsc/CompilerCommand.scala b/src/compiler/scala/tools/nsc/CompilerCommand.scala index bab0768ca9f3..a1d0d52dcf0c 100644 --- a/src/compiler/scala/tools/nsc/CompilerCommand.scala +++ b/src/compiler/scala/tools/nsc/CompilerCommand.scala @@ -20,9 +20,12 @@ class CompilerCommand(arguments: List[String], val settings: Settings) { def ok = processArgumentsResult._1 def files = processArgumentsResult._2 - /** The name of the command */ + /** The name of the command. */ def cmdName = "scalac" + /** A descriptive alias for version and help messages. */ + def cmdDesc = "compiler" + private def explainAdvanced = "\n" + """ |-- Notes on option parsing -- |Boolean settings are always false unless set. @@ -85,7 +88,11 @@ class CompilerCommand(arguments: List[String], val settings: Settings) { def getInfoMessage(global: Global): String = { import settings._ - if (help) usageMsg + global.pluginOptionsHelp + import Properties.{ versionString, copyrightString } //versionFor + def versionFor(command: String) = f"Scala $command $versionString -- $copyrightString" + + if (version) versionFor(cmdDesc) + else if (help) usageMsg + global.pluginOptionsHelp else if (Xhelp) xusageMsg else if (Yhelp) yusageMsg else if (showPlugins) global.pluginDescriptions diff --git a/src/compiler/scala/tools/nsc/Driver.scala b/src/compiler/scala/tools/nsc/Driver.scala index 3ac27a42e864..6befa76b3f10 100644 --- a/src/compiler/scala/tools/nsc/Driver.scala +++ b/src/compiler/scala/tools/nsc/Driver.scala @@ -2,26 +2,24 @@ package scala package tools.nsc import scala.tools.nsc.reporters.ConsoleReporter -import Properties.{ versionString, copyrightString, residentPromptString } +import Properties.{ versionMsg, residentPromptString } import scala.reflect.internal.util.FakePos abstract class Driver { val prompt = residentPromptString - val versionMsg = "Scala compiler " + - versionString + " -- " + - copyrightString - var reporter: ConsoleReporter = _ protected var command: CompilerCommand = _ protected var settings: Settings = _ - protected def scalacError(msg: String) { + protected def scalacError(msg: String): Unit = { reporter.error(FakePos("scalac"), msg + "\n scalac -help gives more information") } - protected def processSettingsHook(): Boolean = true + protected def processSettingsHook(): Boolean = { + if (settings.version) { reporter echo versionMsg ; false } else true + } protected def newCompiler(): Global @@ -37,14 +35,12 @@ abstract class Driver { } def process(args: Array[String]) { - val ss = new Settings(scalacError) - reporter = new ConsoleReporter(ss) + val ss = new Settings(scalacError) + reporter = new ConsoleReporter(ss) command = new CompilerCommand(args.toList, ss) settings = command.settings - if (settings.version) { - reporter.echo(versionMsg) - } else if (processSettingsHook()) { + if (processSettingsHook()) { val compiler = newCompiler() try { if (reporter.hasErrors) @@ -68,5 +64,4 @@ abstract class Driver { process(args) sys.exit(if (reporter.hasErrors) 1 else 0) } - } diff --git a/src/compiler/scala/tools/nsc/GenericRunnerCommand.scala b/src/compiler/scala/tools/nsc/GenericRunnerCommand.scala index 253f18dec6de..dbdeec809f75 100644 --- a/src/compiler/scala/tools/nsc/GenericRunnerCommand.scala +++ b/src/compiler/scala/tools/nsc/GenericRunnerCommand.scala @@ -19,9 +19,10 @@ extends CompilerCommand(args, settings) { def this(args: List[String]) = this(args, str => Console.println("Error: " + str)) - /** name of the associated compiler command */ override def cmdName = "scala" - def compCmdName = "scalac" + override def cmdDesc = "code runner" + + def compCmdName = "scalac" // super.cmdName // change CompilerCommand behavior override def shouldProcessArguments: Boolean = false diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala index 20ccc30ff682..d22dcacad67e 100644 --- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala @@ -42,7 +42,7 @@ trait ScalaSettings extends AbsScalaSettings def optimiseSettings = List[BooleanSetting](inline, inlineHandlers, Xcloselim, Xdce, YconstOptimization) /** If any of these settings is enabled, the compiler should print a message and exit. */ - def infoSettings = List[Setting](help, Xhelp, Yhelp, showPlugins, showPhases, genPhaseGraph) + def infoSettings = List[Setting](version, help, Xhelp, Yhelp, showPlugins, showPhases, genPhaseGraph) /** Is an info setting set? */ def isInfo = infoSettings exists (_.isSetByUser) diff --git a/src/interactive/scala/tools/nsc/interactive/Main.scala b/src/interactive/scala/tools/nsc/interactive/Main.scala index c838606f02b6..7796c656709a 100644 --- a/src/interactive/scala/tools/nsc/interactive/Main.scala +++ b/src/interactive/scala/tools/nsc/interactive/Main.scala @@ -12,7 +12,7 @@ package interactive */ object Main extends nsc.MainClass { override def processSettingsHook(): Boolean = { - if (this.settings.Yidedebug) { + def run(): Unit = { this.settings.Xprintpos.value = true this.settings.Yrangepos.value = true val compiler = new interactive.Global(this.settings, this.reporter) @@ -27,8 +27,9 @@ object Main extends nsc.MainClass { case None => reporter.reset() // Causes other compiler errors to be ignored } askShutdown - false } - else true + super.processSettingsHook() && ( + if (this.settings.Yidedebug) { run() ; false } else true + ) } } diff --git a/src/library/scala/util/Properties.scala b/src/library/scala/util/Properties.scala index d597feb89887..2daa4de9a6df 100644 --- a/src/library/scala/util/Properties.scala +++ b/src/library/scala/util/Properties.scala @@ -155,9 +155,12 @@ private[scala] trait PropertiesTrait { // This is looking for javac, tools.jar, etc. // Tries JDK_HOME first, then the more common but likely jre JAVA_HOME, // and finally the system property based javaHome. - def jdkHome = envOrElse("JDK_HOME", envOrElse("JAVA_HOME", javaHome)) + def jdkHome = envOrElse("JDK_HOME", envOrElse("JAVA_HOME", javaHome)) - def versionMsg = "Scala %s %s -- %s".format(propCategory, versionString, copyrightString) + // private[scala] for 2.12 + private[this] def versionFor(command: String) = f"Scala $command $versionString -- $copyrightString" + + def versionMsg = versionFor(propCategory) def scalaCmd = if (isWin) "scala.bat" else "scala" def scalacCmd = if (isWin) "scalac.bat" else "scalac" diff --git a/src/repl/scala/tools/nsc/MainGenericRunner.scala b/src/repl/scala/tools/nsc/MainGenericRunner.scala index 43f0ea1256ea..34057ed34165 100644 --- a/src/repl/scala/tools/nsc/MainGenericRunner.scala +++ b/src/repl/scala/tools/nsc/MainGenericRunner.scala @@ -8,7 +8,6 @@ package tools.nsc import io.{ File } import util.{ ClassPath, ScalaClassLoader } -import Properties.{ versionString, copyrightString } import GenericRunnerCommand._ object JarRunner extends CommonRunner { @@ -28,79 +27,78 @@ object JarRunner extends CommonRunner { } /** An object that runs Scala code. It has three possible - * sources for the code to run: pre-compiled code, a script file, - * or interactive entry. - */ + * sources for the code to run: pre-compiled code, a script file, + * or interactive entry. + */ class MainGenericRunner { - def errorFn(ex: Throwable): Boolean = { - ex.printStackTrace() - false - } - def errorFn(str: String): Boolean = { - Console.err println str - false + def errorFn(str: String, e: Option[Throwable] = None, isFailure: Boolean = true): Boolean = { + if (str.nonEmpty) Console.err println str + e foreach (_.printStackTrace()) + !isFailure } def process(args: Array[String]): Boolean = { val command = new GenericRunnerCommand(args.toList, (x: String) => errorFn(x)) - import command.{ settings, howToRun, thingToRun } - def sampleCompiler = new Global(settings) // def so its not created unless needed - - if (!command.ok) return errorFn("\n" + command.shortUsageMsg) - else if (settings.version) return errorFn("Scala code runner %s -- %s".format(versionString, copyrightString)) - else if (command.shouldStopWithInfo) return errorFn(command getInfoMessage sampleCompiler) - - def isE = !settings.execute.isDefault - def dashe = settings.execute.value - - def isI = !settings.loadfiles.isDefault - def dashi = settings.loadfiles.value - - // Deadlocks on startup under -i unless we disable async. - if (isI) - settings.Yreplsync.value = true - - def combinedCode = { - val files = if (isI) dashi map (file => File(file).slurp()) else Nil - val str = if (isE) List(dashe) else Nil - - files ++ str mkString "\n\n" - } - - def runTarget(): Either[Throwable, Boolean] = howToRun match { - case AsObject => - ObjectRunner.runAndCatch(settings.classpathURLs, thingToRun, command.arguments) - case AsScript => - ScriptRunner.runScriptAndCatch(settings, thingToRun, command.arguments) - case AsJar => - JarRunner.runJar(settings, thingToRun, command.arguments) - case Error => - Right(false) - case _ => - // We start the repl when no arguments are given. - Right(new interpreter.ILoop process settings) + import command.{ settings, howToRun, thingToRun, shortUsageMsg, shouldStopWithInfo } + def sampleCompiler = new Global(settings) // def so it's not created unless needed + + def run(): Boolean = { + def isE = !settings.execute.isDefault + def dashe = settings.execute.value + + def isI = !settings.loadfiles.isDefault + def dashi = settings.loadfiles.value + + // Deadlocks on startup under -i unless we disable async. + if (isI) + settings.Yreplsync.value = true + + def combinedCode = { + val files = if (isI) dashi map (file => File(file).slurp()) else Nil + val str = if (isE) List(dashe) else Nil + + files ++ str mkString "\n\n" + } + + def runTarget(): Either[Throwable, Boolean] = howToRun match { + case AsObject => + ObjectRunner.runAndCatch(settings.classpathURLs, thingToRun, command.arguments) + case AsScript => + ScriptRunner.runScriptAndCatch(settings, thingToRun, command.arguments) + case AsJar => + JarRunner.runJar(settings, thingToRun, command.arguments) + case Error => + Right(false) + case _ => + // We start the repl when no arguments are given. + Right(new interpreter.ILoop process settings) + } + + /** If -e and -i were both given, we want to execute the -e code after the + * -i files have been included, so they are read into strings and prepended to + * the code given in -e. The -i option is documented to only make sense + * interactively so this is a pretty reasonable assumption. + * + * This all needs a rewrite though. + */ + if (isE) { + ScriptRunner.runCommand(settings, combinedCode, thingToRun +: command.arguments) + } + else runTarget() match { + case Left(ex) => errorFn("", Some(ex)) // there must be a useful message of hope to offer here + case Right(b) => b + } } - /** If -e and -i were both given, we want to execute the -e code after the - * -i files have been included, so they are read into strings and prepended to - * the code given in -e. The -i option is documented to only make sense - * interactively so this is a pretty reasonable assumption. - * - * This all needs a rewrite though. - */ - if (isE) { - ScriptRunner.runCommand(settings, combinedCode, thingToRun +: command.arguments) - } - else runTarget() match { - case Left(ex) => errorFn(ex) - case Right(b) => b - } + if (!command.ok) + errorFn(f"%n$shortUsageMsg") + else if (shouldStopWithInfo) + errorFn(command getInfoMessage sampleCompiler, isFailure = false) + else + run() } } object MainGenericRunner extends MainGenericRunner { - def main(args: Array[String]) { - if (!process(args)) - sys.exit(1) - } + def main(args: Array[String]): Unit = if (!process(args)) sys.exit(1) } From c98aa6f9b149550243b68274e24a6f3174b7f85b Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Fri, 30 May 2014 13:00:38 +0200 Subject: [PATCH 305/826] SI-8637 fixes toolbox phase corruption It turns out, Toolbox.typecheck hasn't been properly re-initializing its state between requests. In particular, globalPhase was left untouched, which made the compiler think that it's past typer, and that in turn disabled implicits. This commit applies a symptomatic fix to this problem. --- src/compiler/scala/tools/reflect/ToolBoxFactory.scala | 1 + test/files/run/t8637.check | 0 test/files/run/t8637.scala | 9 +++++++++ 3 files changed, 10 insertions(+) create mode 100644 test/files/run/t8637.check create mode 100644 test/files/run/t8637.scala diff --git a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala index 3b12086cc740..923297bafbee 100644 --- a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala +++ b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala @@ -141,6 +141,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf => val run = new Run run.symSource(ownerClass) = NoAbstractFile // need to set file to something different from null, so that currentRun.defines works phase = run.typerPhase // need to set a phase to something <= typerPhase, otherwise implicits in typedSelect will be disabled + globalPhase = run.typerPhase // amazing... looks like phase and globalPhase are different things, so we need to set them separately currentTyper.context.setReportErrors() // need to manually set context mode, otherwise typer.silent will throw exceptions reporter.reset() diff --git a/test/files/run/t8637.check b/test/files/run/t8637.check new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/files/run/t8637.scala b/test/files/run/t8637.scala new file mode 100644 index 000000000000..99c8d4c413a1 --- /dev/null +++ b/test/files/run/t8637.scala @@ -0,0 +1,9 @@ +import scala.reflect.runtime.universe._ +import scala.reflect.runtime.currentMirror +import scala.tools.reflect.ToolBox + +object Test extends App { + val tb = currentMirror.mkToolBox() + tb.compile(q"true > true") + tb.typecheck(q"true > true") +} \ No newline at end of file From 2ef193215972321820fcb115b50be4da37d328eb Mon Sep 17 00:00:00 2001 From: Rex Kerr Date: Fri, 30 May 2014 15:08:27 -0700 Subject: [PATCH 306/826] SI-6409 Stream flatMap leaks memory if mapper returns many empties Added Scaladoc explaining that this is necessary behavior, but closed ticket as wontfix. --- src/library/scala/collection/immutable/Stream.scala | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala index 60de147477cf..d3ff5e8abf42 100644 --- a/src/library/scala/collection/immutable/Stream.scala +++ b/src/library/scala/collection/immutable/Stream.scala @@ -97,6 +97,14 @@ import scala.language.implicitConversions * If, on the other hand, there is nothing holding on to the head (e.g. we used * `def` to define the `Stream`) then once it is no longer being used directly, * it disappears. + * + * - Note that some operations, including [[drop]], [[dropWhile]], + * [[flatMap]] or [[collect]] may process a large number of intermediate + * elements before returning. These necessarily hold onto the head, since + * they are methods on `Stream`, and a stream holds its own head. For + * computations of this sort where memoization is not desired, use + * `Iterator` when possible. + * * {{{ * // For example, let's build the natural numbers and do some silly iteration * // over them. From fd001811c662f6daecf91319b36c1ad14a87ff72 Mon Sep 17 00:00:00 2001 From: Evgeny Vereshchagin Date: Sat, 31 May 2014 20:53:28 +0400 Subject: [PATCH 307/826] Make comment consistent with code --- src/library/scala/Predef.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala index 2be6a9dcc1cd..59c89df3fa8b 100644 --- a/src/library/scala/Predef.scala +++ b/src/library/scala/Predef.scala @@ -303,7 +303,7 @@ object Predef extends LowPriorityImplicits with DeprecatedPredef { @inline implicit def augmentString(x: String): StringOps = new StringOps(x) @inline implicit def unaugmentString(x: StringOps): String = x.repr - // printing and reading ----------------------------------------------- + // printing ----------------------------------------------------------- def print(x: Any) = Console.print(x) def println() = Console.println() From 3914e2bca4f28fd565a24506980b3261b4588328 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 22 May 2014 16:40:03 +0200 Subject: [PATCH 308/826] Rewrite BType to a type hierarchy. This makes BTypes more type safe. It fixes at least one bug: the old BTypes are not actually hash-consed. This worked because the equals method used to have a fallback that would compare the represented string character-by-character. --- .../nsc/backend/jvm/BCodeBodyBuilder.scala | 90 +- .../tools/nsc/backend/jvm/BCodeHelpers.scala | 70 +- .../nsc/backend/jvm/BCodeIdiomatic.scala | 129 ++- .../nsc/backend/jvm/BCodeSkelBuilder.scala | 24 +- .../nsc/backend/jvm/BCodeSyncAndTry.scala | 16 +- .../tools/nsc/backend/jvm/BCodeTypes.scala | 142 ++- .../scala/tools/nsc/backend/jvm/BTypes.scala | 884 ++++++------------ .../scala/tools/nsc/transform/Mixin.scala | 2 +- 8 files changed, 508 insertions(+), 849 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index 4af1b553169e..1285ca68629d 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -47,16 +47,16 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { def emit(opc: Int) { mnode.visitInsn(opc) } def emitZeroOf(tk: BType) { - (tk.sort: @switch) match { - case asm.Type.BOOLEAN => bc.boolconst(false) - case asm.Type.BYTE | - asm.Type.SHORT | - asm.Type.CHAR | - asm.Type.INT => bc.iconst(0) - case asm.Type.LONG => bc.lconst(0) - case asm.Type.FLOAT => bc.fconst(0) - case asm.Type.DOUBLE => bc.dconst(0) - case asm.Type.VOID => () + tk match { + case BOOL => bc.boolconst(false) + case BYTE | + SHORT | + CHAR | + INT => bc.iconst(0) + case LONG => bc.lconst(0) + case FLOAT => bc.fconst(0) + case DOUBLE => bc.dconst(0) + case UNIT => () case _ => emit(asm.Opcodes.ACONST_NULL) } } @@ -167,7 +167,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { // load argument on stack assert(args.length == 1, s"Too many arguments for array get operation: $tree"); genLoad(args.head, INT) - generatedType = k.getComponentType + generatedType = k.asArrayBType.componentType bc.aload(elementType) } else if (scalaPrimitives.isArraySet(code)) { @@ -321,7 +321,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { mnode.visitVarInsn(asm.Opcodes.ALOAD, 0) generatedType = if (tree.symbol == ArrayClass) ObjectReference - else brefType(thisName) // inner class (if any) for claszSymbol already tracked. + else ClassBType(thisName) // inner class (if any) for claszSymbol already tracked. } case Select(Ident(nme.EMPTY_PACKAGE_NAME), module) => @@ -419,7 +419,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { if (hostClass == null) internalName(field.owner) else internalName(hostClass) val fieldJName = field.javaSimpleName.toString - val fieldDescr = symInfoTK(field).getDescriptor + val fieldDescr = symInfoTK(field).descriptor val isStatic = field.isStaticMember val opc = if (isLoad) { if (isStatic) asm.Opcodes.GETSTATIC else asm.Opcodes.GETFIELD } @@ -460,7 +460,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { case ClazzTag => val toPush: BType = { val kind = toTypeKind(const.typeValue) - if (kind.isValueType) classLiteral(kind) + if (kind.isPrimitive) classLiteral(kind) else kind } mnode.visitLdcInsn(toPush.toASMType) @@ -469,7 +469,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { val sym = const.symbolValue val ownerName = internalName(sym.owner) val fieldName = sym.javaSimpleName.toString - val fieldDesc = toTypeKind(sym.tpe.underlying).getDescriptor + val fieldDesc = toTypeKind(sym.tpe.underlying).descriptor mnode.visitFieldInsn( asm.Opcodes.GETSTATIC, ownerName, @@ -541,26 +541,28 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { def genTypeApply(): BType = { genLoadQualifier(fun) - if (l.isValueType && r.isValueType) + // TODO @lry make pattern match + if (l.isPrimitive && r.isPrimitive) genConversion(l, r, cast) - else if (l.isValueType) { + else if (l.isPrimitive) { bc drop l if (cast) { - mnode.visitTypeInsn(asm.Opcodes.NEW, classCastExceptionReference.getInternalName) + mnode.visitTypeInsn(asm.Opcodes.NEW, classCastExceptionReference.internalName) bc dup ObjectReference emit(asm.Opcodes.ATHROW) } else { bc boolconst false } } - else if (r.isValueType && cast) { + else if (r.isPrimitive && cast) { abort(s"Erasure should have added an unboxing operation to prevent this cast. Tree: $app") } - else if (r.isValueType) { + else if (r.isPrimitive) { bc isInstance classLiteral(r) } else { - genCast(r, cast) + assert(r.isRef, r) // ensure that it's not a method + genCast(r.asRefBType, cast) } if (cast) r else BOOL @@ -580,7 +582,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { mnode.visitVarInsn(asm.Opcodes.ALOAD, 0) genLoadArguments(args, paramTKs(app)) genCallMethod(fun.symbol, invokeStyle, pos = app.pos) - generatedType = asmMethodType(fun.symbol).getReturnType + generatedType = asmMethodType(fun.symbol).returnType // 'new' constructor call: Note: since constructors are // thought to return an instance of what they construct, @@ -591,13 +593,13 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { assert(ctor.isClassConstructor, s"'new' call to non-constructor: ${ctor.name}") generatedType = tpeTK(tpt) - assert(generatedType.isRefOrArrayType, s"Non reference type cannot be instantiated: $generatedType") + assert(generatedType.isRef, s"Non reference type cannot be instantiated: $generatedType") generatedType match { - case arr if generatedType.isArray => + case arr @ ArrayBType(componentType) => genLoadArguments(args, paramTKs(app)) - val dims = arr.getDimensions - var elemKind = arr.getElementType + val dims = arr.dimension + var elemKind = arr.elementType val argsSize = args.length if (argsSize > dims) { cunit.error(app.pos, s"too many arguments for array constructor: found ${args.length} but array has only $dims dimension(s)") @@ -607,18 +609,18 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { * elemKind = new BType(BType.ARRAY, arr.off + argsSize, arr.len - argsSize) * however the above does not enter a TypeName for each nested arrays in chrs. */ - for (i <- args.length until dims) elemKind = arrayOf(elemKind) + for (i <- args.length until dims) elemKind = ArrayBType(elemKind) } (argsSize : @switch) match { case 1 => bc newarray elemKind case _ => - val descr = ('[' * argsSize) + elemKind.getDescriptor // denotes the same as: arrayN(elemKind, argsSize).getDescriptor + val descr = ('[' * argsSize) + elemKind.descriptor // denotes the same as: arrayN(elemKind, argsSize).descriptor mnode.visitMultiANewArrayInsn(descr, argsSize) } - case rt if generatedType.hasObjectSort => + case rt: ClassBType => assert(exemplar(ctor.owner).c == rt, s"Symbol ${ctor.owner.fullName} is different from $rt") - mnode.visitTypeInsn(asm.Opcodes.NEW, rt.getInternalName) + mnode.visitTypeInsn(asm.Opcodes.NEW, rt.internalName) bc dup generatedType genLoadArguments(args, paramTKs(app)) genCallMethod(ctor, icodes.opcodes.Static(onInstance = true)) @@ -631,7 +633,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { val nativeKind = tpeTK(expr) genLoad(expr, nativeKind) val MethodNameAndType(mname, mdesc) = asmBoxTo(nativeKind) - bc.invokestatic(BoxesRunTime.getInternalName, mname, mdesc) + bc.invokestatic(BoxesRunTime.internalName, mname, mdesc) generatedType = boxResultType(fun.symbol) // was toTypeKind(fun.symbol.tpe.resultType) case Apply(fun @ _, List(expr)) if currentRun.runDefinitions.isUnbox(fun.symbol) => @@ -639,7 +641,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { val boxType = unboxResultType(fun.symbol) // was toTypeKind(fun.symbol.owner.linkedClassOfClass.tpe) generatedType = boxType val MethodNameAndType(mname, mdesc) = asmUnboxTo(boxType) - bc.invokestatic(BoxesRunTime.getInternalName, mname, mdesc) + bc.invokestatic(BoxesRunTime.internalName, mname, mdesc) case app @ Apply(fun, args) => val sym = fun.symbol @@ -684,7 +686,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { case _ => } if ((targetTypeKind != null) && (sym == definitions.Array_clone) && invokeStyle.isDynamic) { - val target: String = targetTypeKind.getInternalName + val target: String = targetTypeKind.asClassBType.internalName bc.invokevirtual(target, "clone", "()Ljava/lang/Object;") } else { @@ -695,7 +697,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { genNormalMethodCall() - generatedType = asmMethodType(sym).getReturnType + generatedType = asmMethodType(sym).returnType } } @@ -707,7 +709,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { val ArrayValue(tpt @ TypeTree(), elems) = av val elmKind = tpeTK(tpt) - val generatedType = arrayOf(elmKind) + val generatedType = ArrayBType(elmKind) lineNumber(av) bc iconst elems.length @@ -877,12 +879,12 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { if (claszSymbol == module.moduleClass && jMethodName != "readResolve" && !inStaticMethod) { mnode.visitVarInsn(asm.Opcodes.ALOAD, 0) } else { - val mbt = symInfoTK(module) + val mbt = symInfoTK(module).asClassBType mnode.visitFieldInsn( asm.Opcodes.GETSTATIC, - mbt.getInternalName /* + "$" */ , + mbt.internalName /* + "$" */ , strMODULE_INSTANCE_FIELD, - mbt.getDescriptor // for nostalgics: toTypeKind(module.tpe).getDescriptor + mbt.descriptor // for nostalgics: toTypeKind(module.tpe).descriptor ) } } @@ -895,7 +897,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { } } - def genCast(to: BType, cast: Boolean) { + def genCast(to: RefBType, cast: Boolean) { if (cast) { bc checkCast to } else { bc isInstance to } } @@ -960,10 +962,10 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { ) val receiver = if (useMethodOwner) methodOwner else hostSymbol val bmOwner = asmClassType(receiver) - val jowner = bmOwner.getInternalName + val jowner = bmOwner.internalName val jname = method.javaSimpleName.toString val bmType = asmMethodType(method) - val mdescr = bmType.getDescriptor + val mdescr = bmType.descriptor def initModule() { // we initialize the MODULE$ field immediately after the super ctor @@ -1026,7 +1028,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { private def genCJUMP(success: asm.Label, failure: asm.Label, op: TestOp, tk: BType) { if (tk.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT bc.emitIF_ICMP(op, success) - } else if (tk.isRefOrArrayType) { // REFERENCE(_) | ARRAY(_) + } else if (tk.isRef) { // REFERENCE(_) | ARRAY(_) bc.emitIF_ACMP(op, success) } else { (tk: @unchecked) match { @@ -1047,7 +1049,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { private def genCZJUMP(success: asm.Label, failure: asm.Label, op: TestOp, tk: BType) { if (tk.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT bc.emitIF(op, success) - } else if (tk.isRefOrArrayType) { // REFERENCE(_) | ARRAY(_) + } else if (tk.isRef) { // REFERENCE(_) | ARRAY(_) // @unchecked because references aren't compared with GT, GE, LT, LE. (op : @unchecked) match { case icodes.EQ => bc emitIFNULL success @@ -1132,7 +1134,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { case ZOR => genZandOrZor(and = false) case code => // TODO !!!!!!!!!! isReferenceType, in the sense of TypeKind? (ie non-array, non-boxed, non-nothing, may be null) - if (scalaPrimitives.isUniversalEqualityOp(code) && tpeTK(lhs).hasObjectSort) { + if (scalaPrimitives.isUniversalEqualityOp(code) && tpeTK(lhs).isClass) { // `lhs` has reference type if (code == EQ) genEqEqPrimitive(lhs, rhs, success, failure) else genEqEqPrimitive(lhs, rhs, failure, success) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala index d812f6b58d13..51bfdf002720 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala @@ -56,7 +56,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { /* * can-multi-thread */ - def firstCommonSuffix(as: List[Tracked], bs: List[Tracked]): BType = { + def firstCommonSuffix(as: List[Tracked], bs: List[Tracked]): ClassBType = { var chainA = as var chainB = bs var fcs: Tracked = null @@ -85,10 +85,10 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { * can-multi-thread */ override def getCommonSuperClass(inameA: String, inameB: String): String = { - val a = brefType(lookupTypeName(inameA.toCharArray)) - val b = brefType(lookupTypeName(inameB.toCharArray)) + val a = ClassBType(lookupTypeName(inameA.toCharArray)) + val b = ClassBType(lookupTypeName(inameB.toCharArray)) val lca = jvmWiseLUB(a, b) - val lcaName = lca.getInternalName // don't call javaName because that side-effects innerClassBuffer. + val lcaName = lca.internalName // don't call javaName because that side-effects innerClassBuffer. assert(lcaName != "scala/Any") lcaName // ASM caches the answer during the lifetime of a ClassWriter. We outlive that. Not sure whether caching on our side would improve things. @@ -106,7 +106,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { * * can-multi-thread */ - def jvmWiseLUB(a: BType, b: BType): BType = { + def jvmWiseLUB(a: ClassBType, b: ClassBType): ClassBType = { assert(a.isNonSpecial, s"jvmWiseLUB() received a non-plain-class $a") assert(b.isNonSpecial, s"jvmWiseLUB() received a non-plain-class $b") @@ -403,14 +403,14 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { * * must-single-thread */ - final def internalName(sym: Symbol): String = asmClassType(sym).getInternalName + final def internalName(sym: Symbol): String = asmClassType(sym).internalName /* * Tracks (if needed) the inner class given by `sym`. * * must-single-thread */ - final def asmClassType(sym: Symbol): BType = { + final def asmClassType(sym: Symbol): ClassBType = { assert( hasInternalName(sym), { @@ -516,17 +516,18 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { case _: ConstantType => toTypeKind(t.underlying) case TypeRef(_, sym, args) => - if (sym == ArrayClass) arrayOf(toTypeKind(args.head)) + if (sym == ArrayClass) ArrayBType(toTypeKind(args.head)) else primitiveOrRefType2(sym) case ClassInfoType(_, _, sym) => assert(sym != ArrayClass, "ClassInfoType to ArrayClass!") primitiveOrRefType(sym) + // TODO @lry check below comments / todo's // !!! Iulian says types which make no sense after erasure should not reach here, which includes the ExistentialType, AnnotatedType, RefinedType. case ExistentialType(_, t) => toTypeKind(t) // TODO shouldn't get here but the following does: akka-actor/src/main/scala/akka/util/WildcardTree.scala case AnnotatedType(_, w) => toTypeKind(w) // TODO test/files/jvm/annotations.scala causes an AnnotatedType to reach here. - case RefinedType(parents, _) => parents map toTypeKind reduceLeft jvmWiseLUB + case RefinedType(parents, _) => parents.map(toTypeKind(_).asClassBType) reduceLeft jvmWiseLUB // For sure WildcardTypes shouldn't reach here either, but when debugging such situations this may come in handy. // case WildcardType => REFERENCE(ObjectClass) @@ -540,12 +541,12 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { /* * must-single-thread */ - def asmMethodType(msym: Symbol): BType = { + def asmMethodType(msym: Symbol): MethodBType = { assert(msym.isMethod, s"not a method-symbol: $msym") val resT: BType = - if (msym.isClassConstructor || msym.isConstructor) BType.VOID_TYPE - else toTypeKind(msym.tpe.resultType); - BType.getMethodType( resT, mkArray(msym.tpe.paramTypes map toTypeKind) ) + if (msym.isClassConstructor || msym.isConstructor) UNIT + else toTypeKind(msym.tpe.resultType) + MethodBType(msym.tpe.paramTypes map toTypeKind, resT) } /* @@ -579,14 +580,14 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { * * must-single-thread */ - final def descriptor(t: Type): String = { toTypeKind(t).getDescriptor } + final def descriptor(t: Type): String = { toTypeKind(t).descriptor } /* * Tracks (if needed) the inner class given by `sym`. * * must-single-thread */ - final def descriptor(sym: Symbol): String = { asmClassType(sym).getDescriptor } + final def descriptor(sym: Symbol): String = { asmClassType(sym).descriptor } } // end of trait BCInnerClassGen @@ -802,7 +803,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { val thrownExceptions: List[String] = getExceptions(throws) val jReturnType = toTypeKind(methodInfo.resultType) - val mdesc = BType.getMethodType(jReturnType, mkArray(paramJavaTypes)).getDescriptor + val mdesc = MethodBType(paramJavaTypes, jReturnType).descriptor val mirrorMethodName = m.javaSimpleName.toString val mirrorMethod: asm.MethodVisitor = jclass.visitMethod( flags, @@ -821,13 +822,13 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { var index = 0 for(jparamType <- paramJavaTypes) { - mirrorMethod.visitVarInsn(jparamType.getOpcode(asm.Opcodes.ILOAD), index) - assert(jparamType.sort != BType.METHOD, jparamType) - index += jparamType.getSize + mirrorMethod.visitVarInsn(jparamType.typedOpcode(asm.Opcodes.ILOAD), index) + assert(!jparamType.isInstanceOf[MethodBType], jparamType) + index += jparamType.size } - mirrorMethod.visitMethodInsn(asm.Opcodes.INVOKEVIRTUAL, moduleName, mirrorMethodName, asmMethodType(m).getDescriptor, false) - mirrorMethod.visitInsn(jReturnType.getOpcode(asm.Opcodes.IRETURN)) + mirrorMethod.visitMethodInsn(asm.Opcodes.INVOKEVIRTUAL, moduleName, mirrorMethodName, asmMethodType(m).descriptor, false) + mirrorMethod.visitInsn(jReturnType.typedOpcode(asm.Opcodes.IRETURN)) mirrorMethod.visitMaxs(0, 0) // just to follow protocol, dummy arguments mirrorMethod.visitEnd() @@ -995,7 +996,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { flags, mirrorName, null /* no java-generic-signature */, - JAVA_LANG_OBJECT.getInternalName, + JAVA_LANG_OBJECT.internalName, EMPTY_STRING_ARRAY ) @@ -1087,12 +1088,11 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { EMPTY_STRING_ARRAY // no throwable exceptions ) - val stringArrayJType: BType = arrayOf(JAVA_LANG_STRING) - val conJType: BType = - BType.getMethodType( - BType.VOID_TYPE, - Array(exemplar(definitions.ClassClass).c, stringArrayJType, stringArrayJType) - ) + val stringArrayJType: BType = ArrayBType(JAVA_LANG_STRING) + val conJType: BType = MethodBType( + exemplar(definitions.ClassClass).c :: stringArrayJType :: stringArrayJType :: Nil, + UNIT + ) def push(lst: List[String]) { var fi = 0 @@ -1101,7 +1101,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { constructor.visitLdcInsn(new java.lang.Integer(fi)) if (f == null) { constructor.visitInsn(asm.Opcodes.ACONST_NULL) } else { constructor.visitLdcInsn(f) } - constructor.visitInsn(JAVA_LANG_STRING.getOpcode(asm.Opcodes.IASTORE)) + constructor.visitInsn(JAVA_LANG_STRING.typedOpcode(asm.Opcodes.IASTORE)) fi += 1 } } @@ -1114,17 +1114,17 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { // push the string array of field information constructor.visitLdcInsn(new java.lang.Integer(fieldList.length)) - constructor.visitTypeInsn(asm.Opcodes.ANEWARRAY, JAVA_LANG_STRING.getInternalName) + constructor.visitTypeInsn(asm.Opcodes.ANEWARRAY, JAVA_LANG_STRING.internalName) push(fieldList) // push the string array of method information constructor.visitLdcInsn(new java.lang.Integer(methodList.length)) - constructor.visitTypeInsn(asm.Opcodes.ANEWARRAY, JAVA_LANG_STRING.getInternalName) + constructor.visitTypeInsn(asm.Opcodes.ANEWARRAY, JAVA_LANG_STRING.internalName) push(methodList) // invoke the superclass constructor, which will do the // necessary java reflection and create Method objects. - constructor.visitMethodInsn(asm.Opcodes.INVOKESPECIAL, "scala/beans/ScalaBeanInfo", INSTANCE_CONSTRUCTOR_NAME, conJType.getDescriptor, false) + constructor.visitMethodInsn(asm.Opcodes.INVOKESPECIAL, "scala/beans/ScalaBeanInfo", INSTANCE_CONSTRUCTOR_NAME, conJType.descriptor, false) constructor.visitInsn(asm.Opcodes.RETURN) constructor.visitMaxs(0, 0) // just to follow protocol, dummy arguments @@ -1163,7 +1163,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { def legacyAddCreatorCode(clinit: asm.MethodVisitor, cnode: asm.tree.ClassNode, thisName: String) { // this tracks the inner class in innerClassBufferASM, if needed. val androidCreatorType = asmClassType(AndroidCreatorClass) - val tdesc_creator = androidCreatorType.getDescriptor + val tdesc_creator = androidCreatorType.descriptor cnode.visitField( PublicStaticFinal, @@ -1184,12 +1184,12 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { ) // INVOKEVIRTUAL `moduleName`.CREATOR() : android.os.Parcelable$Creator; - val bt = BType.getMethodType(androidCreatorType, Array.empty[BType]) + val bt = MethodBType(Nil, androidCreatorType) clinit.visitMethodInsn( asm.Opcodes.INVOKEVIRTUAL, moduleName, "CREATOR", - bt.getDescriptor, + bt.descriptor, false ) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala index e83453f51e60..9b7c9759607a 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala @@ -9,8 +9,7 @@ package backend.jvm import scala.tools.asm import scala.annotation.switch -import scala.collection.{ immutable, mutable } -import collection.convert.Wrappers.JListWrapper +import scala.collection.mutable /* * A high-level facade to the ASM API for bytecode generation. @@ -52,12 +51,12 @@ abstract class BCodeIdiomatic extends SubComponent { val CLASS_CONSTRUCTOR_NAME = "" val INSTANCE_CONSTRUCTOR_NAME = "" - val ObjectReference = brefType("java/lang/Object") + val ObjectReference = ClassBType("java/lang/Object") val AnyRefReference = ObjectReference - val objArrayReference = arrayOf(ObjectReference) + val objArrayReference = ArrayBType(ObjectReference) val JAVA_LANG_OBJECT = ObjectReference - val JAVA_LANG_STRING = brefType("java/lang/String") + val JAVA_LANG_STRING = ClassBType("java/lang/String") var StringBuilderReference: BType = null @@ -116,17 +115,6 @@ abstract class BCodeIdiomatic extends SubComponent { a } - /* - * The type of 1-dimensional arrays of `elem` type. - * The invoker is responsible for tracking (if needed) the inner class given by the elem BType. - * - * must-single-thread - */ - final def arrayOf(elem: BType): BType = { - assert(!(elem.isUnitType), s"The element type of an array can't be: $elem") - brefType("[" + elem.getDescriptor) - } - /* Just a namespace for utilities that encapsulate MethodVisitor idioms. * In the ASM world, org.objectweb.asm.commons.InstructionAdapter plays a similar role, * but the methods here allow choosing when to transition from ICode to ASM types @@ -250,12 +238,12 @@ abstract class BCodeIdiomatic extends SubComponent { final def genStringConcat(el: BType) { val jtype = - if (el.isArray || el.hasObjectSort) JAVA_LANG_OBJECT - else el; + if (el.isArray || el.isClass) JAVA_LANG_OBJECT + else el - val bt = BType.getMethodType(StringBuilderReference, Array(jtype)) + val bt = MethodBType(List(jtype), StringBuilderReference) - invokevirtual(StringBuilderClassName, "append", bt.getDescriptor) + invokevirtual(StringBuilderClassName, "append", bt.descriptor) } /* @@ -276,7 +264,7 @@ abstract class BCodeIdiomatic extends SubComponent { final def emitT2T(from: BType, to: BType) { assert( - from.isNonUnitValueType && to.isNonUnitValueType, + from.isNonVoidPrimitiveType && to.isNonVoidPrimitiveType, s"Cannot emit primitive conversion from $from to $to" ) @@ -298,37 +286,37 @@ abstract class BCodeIdiomatic extends SubComponent { assert(from != BOOL && to != BOOL, s"inconvertible types : $from -> $to") // We're done with BOOL already - (from.sort: @switch) match { + from match { // using `asm.Type.SHORT` instead of `BType.SHORT` because otherwise "warning: could not emit switch for @switch annotated match" - case asm.Type.BYTE => pickOne(JCodeMethodN.fromByteT2T) - case asm.Type.SHORT => pickOne(JCodeMethodN.fromShortT2T) - case asm.Type.CHAR => pickOne(JCodeMethodN.fromCharT2T) - case asm.Type.INT => pickOne(JCodeMethodN.fromIntT2T) + case BYTE => pickOne(JCodeMethodN.fromByteT2T) + case SHORT => pickOne(JCodeMethodN.fromShortT2T) + case CHAR => pickOne(JCodeMethodN.fromCharT2T) + case INT => pickOne(JCodeMethodN.fromIntT2T) - case asm.Type.FLOAT => + case FLOAT => import asm.Opcodes.{ F2L, F2D, F2I } - (to.sort: @switch) match { - case asm.Type.LONG => emit(F2L) - case asm.Type.DOUBLE => emit(F2D) - case _ => emit(F2I); emitT2T(INT, to) + to match { + case LONG => emit(F2L) + case DOUBLE => emit(F2D) + case _ => emit(F2I); emitT2T(INT, to) } - case asm.Type.LONG => + case LONG => import asm.Opcodes.{ L2F, L2D, L2I } - (to.sort: @switch) match { - case asm.Type.FLOAT => emit(L2F) - case asm.Type.DOUBLE => emit(L2D) - case _ => emit(L2I); emitT2T(INT, to) + to match { + case FLOAT => emit(L2F) + case DOUBLE => emit(L2D) + case _ => emit(L2I); emitT2T(INT, to) } - case asm.Type.DOUBLE => + case DOUBLE => import asm.Opcodes.{ D2L, D2F, D2I } - (to.sort: @switch) match { - case asm.Type.FLOAT => emit(D2F) - case asm.Type.LONG => emit(D2L) - case _ => emit(D2I); emitT2T(INT, to) + to match { + case FLOAT => emit(D2F) + case LONG => emit(D2L) + case _ => emit(D2I); emitT2T(INT, to) } } } // end of emitT2T() @@ -380,24 +368,26 @@ abstract class BCodeIdiomatic extends SubComponent { // can-multi-thread final def newarray(elem: BType) { - if (elem.isRefOrArrayType || elem.isPhantomType ) { - /* phantom type at play in `Array(null)`, SI-1513. On the other hand, Array(()) has element type `scala.runtime.BoxedUnit` which hasObjectSort. */ - jmethod.visitTypeInsn(Opcodes.ANEWARRAY, elem.getInternalName) - } else { - val rand = { - // using `asm.Type.SHORT` instead of `BType.SHORT` because otherwise "warning: could not emit switch for @switch annotated match" - (elem.sort: @switch) match { - case asm.Type.BOOLEAN => Opcodes.T_BOOLEAN - case asm.Type.BYTE => Opcodes.T_BYTE - case asm.Type.SHORT => Opcodes.T_SHORT - case asm.Type.CHAR => Opcodes.T_CHAR - case asm.Type.INT => Opcodes.T_INT - case asm.Type.LONG => Opcodes.T_LONG - case asm.Type.FLOAT => Opcodes.T_FLOAT - case asm.Type.DOUBLE => Opcodes.T_DOUBLE + elem match { + case c: RefBType => + /* phantom type at play in `Array(null)`, SI-1513. On the other hand, Array(()) has element type `scala.runtime.BoxedUnit` which isObject. */ + jmethod.visitTypeInsn(Opcodes.ANEWARRAY, c.classOrArrayType) + case _ => + assert(elem.isNonVoidPrimitiveType) + val rand = { + // using `asm.Type.SHORT` instead of `BType.SHORT` because otherwise "warning: could not emit switch for @switch annotated match" + elem match { + case BOOL => Opcodes.T_BOOLEAN + case BYTE => Opcodes.T_BYTE + case SHORT => Opcodes.T_SHORT + case CHAR => Opcodes.T_CHAR + case INT => Opcodes.T_INT + case LONG => Opcodes.T_LONG + case FLOAT => Opcodes.T_FLOAT + case DOUBLE => Opcodes.T_DOUBLE + } } - } - jmethod.visitIntInsn(Opcodes.NEWARRAY, rand) + jmethod.visitIntInsn(Opcodes.NEWARRAY, rand) } } @@ -537,7 +527,7 @@ abstract class BCodeIdiomatic extends SubComponent { // can-multi-thread final def emitVarInsn(opc: Int, idx: Int, tk: BType) { assert((opc == Opcodes.ILOAD) || (opc == Opcodes.ISTORE), opc) - jmethod.visitVarInsn(tk.getOpcode(opc), idx) + jmethod.visitVarInsn(tk.typedOpcode(opc), idx) } // ---------------- array load and store ---------------- @@ -546,7 +536,7 @@ abstract class BCodeIdiomatic extends SubComponent { final def emitTypeBased(opcs: Array[Int], tk: BType) { assert(tk != UNIT, tk) val opc = { - if (tk.isRefOrArrayType) { opcs(0) } + if (tk.isRef) { opcs(0) } else if (tk.isIntSizedType) { (tk: @unchecked) match { case BOOL | BYTE => opcs(1) @@ -571,11 +561,11 @@ abstract class BCodeIdiomatic extends SubComponent { final def emitPrimitive(opcs: Array[Int], tk: BType) { val opc = { // using `asm.Type.SHORT` instead of `BType.SHORT` because otherwise "warning: could not emit switch for @switch annotated match" - (tk.sort: @switch) match { - case asm.Type.LONG => opcs(1) - case asm.Type.FLOAT => opcs(2) - case asm.Type.DOUBLE => opcs(3) - case _ => opcs(0) + tk match { + case LONG => opcs(1) + case FLOAT => opcs(2) + case DOUBLE => opcs(3) + case _ => opcs(0) } } emit(opc) @@ -590,15 +580,14 @@ abstract class BCodeIdiomatic extends SubComponent { // ---------------- type checks and casts ---------------- // can-multi-thread - final def isInstance(tk: BType) { - jmethod.visitTypeInsn(Opcodes.INSTANCEOF, tk.getInternalName) + final def isInstance(tk: RefBType): Unit = { + jmethod.visitTypeInsn(Opcodes.INSTANCEOF, tk.classOrArrayType) } // can-multi-thread - final def checkCast(tk: BType) { - assert(tk.isRefOrArrayType, s"checkcast on primitive type: $tk") + final def checkCast(tk: RefBType): Unit = { // TODO ICode also requires: but that's too much, right? assert(!isBoxedType(tk), "checkcast on boxed type: " + tk) - jmethod.visitTypeInsn(Opcodes.CHECKCAST, tk.getInternalName) + jmethod.visitTypeInsn(Opcodes.CHECKCAST, tk.classOrArrayType) } } // end of class JCodeMethodN diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala index a9ba1945d20b..effc68c5e317 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala @@ -134,7 +134,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { private def initJClass(jclass: asm.ClassVisitor) { val ps = claszSymbol.info.parents - val superClass: String = if (ps.isEmpty) JAVA_LANG_OBJECT.getInternalName else internalName(ps.head.typeSymbol); + val superClass: String = if (ps.isEmpty) JAVA_LANG_OBJECT.internalName else internalName(ps.head.typeSymbol); val ifaces: Array[String] = { val arrIfacesTr: Array[Tracked] = exemplar(claszSymbol).ifaces val arrIfaces = new Array[String](arrIfacesTr.length) @@ -143,7 +143,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { val ifaceTr = arrIfacesTr(i) val bt = ifaceTr.c if (ifaceTr.isInnerClass) { innerClassBufferASM += bt } - arrIfaces(i) = bt.getInternalName + arrIfaces(i) = bt.internalName i += 1 } arrIfaces @@ -167,7 +167,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { val enclM = getEnclosingMethodAttribute(claszSymbol) if (enclM != null) { val EnclMethodEntry(className, methodName, methodType) = enclM - cnode.visitOuterClass(className, methodName, methodType.getDescriptor) + cnode.visitOuterClass(className, methodName, methodType.descriptor) } val ssa = getAnnotPickle(thisName, claszSymbol) @@ -262,7 +262,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { val jfield = new asm.tree.FieldNode( flags, f.javaSimpleName.toString, - symInfoTK(f).getDescriptor, + symInfoTK(f).descriptor, javagensig, null // no initial value ) @@ -398,8 +398,8 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { assert(nxtIdx != -1, "not a valid start index") val loc = Local(tk, sym.javaSimpleName.toString, nxtIdx, sym.isSynthetic) slots += (sym -> loc) - assert(tk.getSize > 0, "makeLocal called for a symbol whose type is Unit.") - nxtIdx += tk.getSize + assert(tk.size > 0, "makeLocal called for a symbol whose type is Unit.") + nxtIdx += tk.size loc } @@ -532,7 +532,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { if (isMethSymStaticCtor) CLASS_CONSTRUCTOR_NAME else jMethodName - val mdesc = asmMethodType(methSymbol).getDescriptor + val mdesc = asmMethodType(methSymbol).descriptor mnode = cnode.visitMethod( flags, bytecodeName, @@ -556,7 +556,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { methSymbol = dd.symbol jMethodName = methSymbol.javaSimpleName.toString - returnType = asmMethodType(dd.symbol).getReturnType + returnType = asmMethodType(dd.symbol).returnType isMethSymStaticCtor = methSymbol.isStaticConstructor resetMethodBookkeeping(dd) @@ -686,7 +686,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { val callee = methSymbol.enclClass.primaryConstructor val jname = callee.javaSimpleName.toString val jowner = internalName(callee.owner) - val jtype = asmMethodType(callee).getDescriptor + val jtype = asmMethodType(callee).descriptor insnModB = new asm.tree.MethodInsnNode(asm.Opcodes.INVOKESPECIAL, jowner, jname, jtype, false) } @@ -695,7 +695,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { // android creator code if (isCZParcelable) { // add a static field ("CREATOR") to this class to cache android.os.Parcelable$Creator - val andrFieldDescr = asmClassType(AndroidCreatorClass).getDescriptor + val andrFieldDescr = asmClassType(AndroidCreatorClass).descriptor cnode.visitField( asm.Opcodes.ACC_STATIC | asm.Opcodes.ACC_FINAL, "CREATOR", @@ -707,7 +707,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { val callee = definitions.getMember(claszSymbol.companionModule, androidFieldName) val jowner = internalName(callee.owner) val jname = callee.javaSimpleName.toString - val jtype = asmMethodType(callee).getDescriptor + val jtype = asmMethodType(callee).descriptor insnParcA = new asm.tree.MethodInsnNode(asm.Opcodes.INVOKESTATIC, jowner, jname, jtype, false) // PUTSTATIC `thisName`.CREATOR; insnParcB = new asm.tree.FieldInsnNode(asm.Opcodes.PUTSTATIC, thisName, "CREATOR", andrFieldDescr) @@ -724,7 +724,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { def emitLocalVarScope(sym: Symbol, start: asm.Label, end: asm.Label, force: Boolean = false) { val Local(tk, name, idx, isSynth) = locals(sym) if (force || !isSynth) { - mnode.visitLocalVariable(name, tk.getDescriptor, null, start, end, idx) + mnode.visitLocalVariable(name, tk.descriptor, null, start, end, idx) } } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala index 5801b5e09c6b..c271e7b129e7 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala @@ -9,9 +9,7 @@ package tools.nsc package backend package jvm -import scala.collection.{ mutable, immutable } -import scala.annotation.switch - +import scala.collection.immutable import scala.tools.asm /* @@ -185,7 +183,7 @@ abstract class BCodeSyncAndTry extends BCodeBodyBuilder { val caseHandlers: List[EHClause] = for (CaseDef(pat, _, caseBody) <- catches) yield { pat match { - case Typed(Ident(nme.WILDCARD), tpt) => NamelessEH(tpeTK(tpt), caseBody) + case Typed(Ident(nme.WILDCARD), tpt) => NamelessEH(tpeTK(tpt).asClassBType, caseBody) case Ident(nme.WILDCARD) => NamelessEH(ThrowableReference, caseBody) case Bind(_, _) => BoundEH (pat.symbol, caseBody) } @@ -251,7 +249,7 @@ abstract class BCodeSyncAndTry extends BCodeBodyBuilder { // (2.a) emit case clause proper val startHandler = currProgramPoint() var endHandler: asm.Label = null - var excType: BType = null + var excType: ClassBType = null registerCleanup(finCleanup) ch match { case NamelessEH(typeToDrop, caseBody) => @@ -270,7 +268,7 @@ abstract class BCodeSyncAndTry extends BCodeBodyBuilder { nopIfNeeded(startHandler) endHandler = currProgramPoint() emitLocalVarScope(patSymbol, startHandler, endHandler) - excType = patTK + excType = patTK.asClassBType } unregisterCleanup(finCleanup) // (2.b) mark the try-body as protected by this case clause. @@ -358,10 +356,10 @@ abstract class BCodeSyncAndTry extends BCodeBodyBuilder { } } - def protect(start: asm.Label, end: asm.Label, handler: asm.Label, excType: BType) { + def protect(start: asm.Label, end: asm.Label, handler: asm.Label, excType: ClassBType) { val excInternalName: String = if (excType == null) null - else excType.getInternalName + else excType.internalName assert(start != end, "protecting a range of zero instructions leads to illegal class format. Solution: add a NOP to that range.") mnode.visitTryCatchBlock(start, end, handler, excInternalName) } @@ -388,7 +386,7 @@ abstract class BCodeSyncAndTry extends BCodeBodyBuilder { def mayCleanStack(tree: Tree): Boolean = tree exists { t => t.isInstanceOf[Try] } trait EHClause - case class NamelessEH(typeToDrop: BType, caseBody: Tree) extends EHClause + case class NamelessEH(typeToDrop: ClassBType, caseBody: Tree) extends EHClause case class BoundEH (patSymbol: Symbol, caseBody: Tree) extends EHClause } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala index 20c2c5210361..62dfb4917d09 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala @@ -25,18 +25,18 @@ abstract class BCodeTypes extends BCodeIdiomatic { val isCompilingStdLib = !(settings.sourcepath.isDefault) // special names - var StringReference : BType = null - var ThrowableReference : BType = null - var jlCloneableReference : BType = null // java/lang/Cloneable - var jlNPEReference : BType = null // java/lang/NullPointerException - var jioSerializableReference : BType = null // java/io/Serializable - var scalaSerializableReference : BType = null // scala/Serializable - var classCastExceptionReference : BType = null // java/lang/ClassCastException + var StringReference : ClassBType = null + var ThrowableReference : ClassBType = null + var jlCloneableReference : ClassBType = null // java/lang/Cloneable + var jlNPEReference : ClassBType = null // java/lang/NullPointerException + var jioSerializableReference : ClassBType = null // java/io/Serializable + var scalaSerializableReference : ClassBType = null // scala/Serializable + var classCastExceptionReference : ClassBType = null // java/lang/ClassCastException /* A map from scala primitive type-symbols to BTypes */ var primitiveTypeMap: Map[Symbol, BType] = null /* A map from scala type-symbols for Nothing and Null to (runtime version) BTypes */ - var phantomTypeMap: Map[Symbol, BType] = null + var phantomTypeMap: Map[Symbol, ClassBType] = null /* Maps the method symbol for a box method to the boxed type of the result. * For example, the method symbol for `Byte.box()`) is mapped to the BType `Ljava/lang/Integer;`. */ var boxResultType: Map[Symbol, BType] = null @@ -61,10 +61,10 @@ abstract class BCodeTypes extends BCodeIdiomatic { val AbstractFunctionReference = new Array[Tracked](definitions.MaxFunctionArity + 1) val abstractFunctionArityMap = mutable.Map.empty[BType, Int] - var PartialFunctionReference: BType = null // scala.PartialFunction - var AbstractPartialFunctionReference: BType = null // scala.runtime.AbstractPartialFunction + var PartialFunctionReference: ClassBType = null // scala.PartialFunction + var AbstractPartialFunctionReference: ClassBType = null // scala.runtime.AbstractPartialFunction - var BoxesRunTime: BType = null + var BoxesRunTime: ClassBType = null /* * must-single-thread @@ -105,7 +105,7 @@ abstract class BCodeTypes extends BCodeIdiomatic { // Other than that, they aren't needed there (e.g., `isSubtypeOf()` special-cases boxed classes, similarly for others). val boxedClasses = List(BoxedBooleanClass, BoxedCharacterClass, BoxedByteClass, BoxedShortClass, BoxedIntClass, BoxedLongClass, BoxedFloatClass, BoxedDoubleClass) for(csym <- boxedClasses) { - val key = brefType(csym.javaBinaryName.toTypeName) + val key = ClassBType(csym.javaBinaryName.toTypeName) val tr = buildExemplar(key, csym) symExemplars.put(csym, tr) exemplars.put(tr.c, tr) @@ -145,16 +145,6 @@ abstract class BCodeTypes extends BCodeIdiomatic { scalaSerializableReference = exemplar(SerializableClass).c classCastExceptionReference = exemplar(ClassCastExceptionClass).c - /* - * The bytecode emitter special-cases String concatenation, in that three methods of `JCodeMethodN` - * ( `genStartConcat()` , `genStringConcat()` , and `genEndConcat()` ) - * don't obtain the method descriptor of the callee via `asmMethodType()` (as normally done) - * but directly emit callsites on StringBuilder using literal constant for method descriptors. - * In order to make sure those method descriptors are available as BTypes, they are initialized here. - */ - BType.getMethodType("()V") // necessary for JCodeMethodN.genStartConcat - BType.getMethodType("()Ljava/lang/String;") // necessary for JCodeMethodN.genEndConcat - PartialFunctionReference = exemplar(PartialFunctionClass).c for(idx <- 0 to definitions.MaxFunctionArity) { FunctionReference(idx) = exemplar(FunctionClass(idx)) @@ -163,12 +153,7 @@ abstract class BCodeTypes extends BCodeIdiomatic { AbstractPartialFunctionReference = exemplar(AbstractPartialFunctionClass).c } - // later a few analyses (e.g. refreshInnerClasses) will look up BTypes based on descriptors in instructions - // we make sure those BTypes can be found via lookup as opposed to creating them on the fly. - BoxesRunTime = brefType("scala/runtime/BoxesRunTime") - asmBoxTo.values foreach { mnat: MethodNameAndType => BType.getMethodType(mnat.mdesc) } - asmUnboxTo.values foreach { mnat: MethodNameAndType => BType.getMethodType(mnat.mdesc) } - + BoxesRunTime = ClassBType("scala/runtime/BoxesRunTime") } /* @@ -189,28 +174,41 @@ abstract class BCodeTypes extends BCodeIdiomatic { // allowing answering `conforms()` without resorting to typer. // ------------------------------------------------ - val exemplars = new java.util.concurrent.ConcurrentHashMap[BType, Tracked] - val symExemplars = new java.util.concurrent.ConcurrentHashMap[Symbol, Tracked] + /** + * TODO @lry should probably be a map form ClassBType to Tracked + */ + val exemplars = new java.util.concurrent.ConcurrentHashMap[BType, Tracked] - /* - * Typically, a question about a BType can be answered only by using the BType as lookup key in one or more maps. - * A `Tracked` object saves time by holding together information required to answer those questions: + /** + * Maps class symbols to their corresponding `Tracked` instance. + */ + val symExemplars = new java.util.concurrent.ConcurrentHashMap[Symbol, Tracked] + + /** + * A `Tracked` instance stores information about a BType. This allows ansering type questions + * without resolving to the compiler, in a thread-safe manner, in particular isSubtypeOf. * - * - `sc` denotes the bytecode-level superclass if any, null otherwise + * @param c the BType described by this `Tracked` + * @param flags the java flags for the type, computed by BCodeTypes#javaFlags + * @param sc the bytecode-level superclass if any, null otherwise + * @param ifaces the interfaces explicitly declared. Not included are those transitively + * supported, but the utility method `allLeafIfaces()` can be used for that. + * @param innersChain the containing classes for a non-package-level class `c`, null otherwise. * - * - `ifaces` denotes the interfaces explicitly declared. - * Not included are those transitively supported, but the utility method `allLeafIfaces()` can be used for that. + * Note: the optimizer may inline anonymous closures, thus eliding those inner classes (no + * physical class file is emitted for elided classes). Before committing `innersChain` to + * bytecode, cross-check with the list of elided classes (SI-6546). * - * - `innersChain` denotes the containing classes for a non-package-level class `c`, null otherwise. - * Note: the optimizer may inline anonymous closures, thus eliding those inner classes - * (no physical class file is emitted for elided classes). - * Before committing `innersChain` to bytecode, cross-check with the list of elided classes (SI-6546). + * All methods of this class can-multi-thread * - * All methods of this class can-multi-thread + * TODO @lry c: ClassBType. rename to ClassBTypeInfo */ - case class Tracked(c: BType, flags: Int, sc: Tracked, ifaces: Array[Tracked], innersChain: Array[InnerClassEntry]) { + case class Tracked(c: ClassBType, flags: Int, sc: Tracked, ifaces: Array[Tracked], innersChain: Array[InnerClassEntry]) { // not a case-field because we initialize it only for JVM classes we emit. + // TODO @lry make it an Option[List[BType]] + // TODO: this is currently not used. a commit in the optimizer branch uses this field to + // re-compute inner classes (ee4c185). leaving it in for now. private var _directMemberClasses: List[BType] = null def directMemberClasses: List[BType] = { @@ -221,9 +219,9 @@ abstract class BCodeTypes extends BCodeIdiomatic { def directMemberClasses_=(bs: List[BType]) { if (_directMemberClasses != null) { // TODO we enter here when both mirror class and plain class are emitted for the same ModuleClassSymbol. - assert(_directMemberClasses == bs.sortBy(_.off)) + assert(_directMemberClasses.sameElements(bs)) } - _directMemberClasses = bs.sortBy(_.off) + _directMemberClasses = bs } /* `isCompilingStdLib` saves the day when compiling: @@ -245,7 +243,7 @@ abstract class BCodeTypes extends BCodeIdiomatic { def isInnerClass = { innersChain != null } def isLambda = { // ie isLCC || isTraditionalClosureClass - isFinal && (c.getSimpleName.contains(tpnme.ANON_FUN_NAME.toString)) && isFunctionType(c) + isFinal && (c.simpleName.contains(tpnme.ANON_FUN_NAME.toString)) && isFunctionType(c) } /* can-multi-thread */ @@ -378,8 +376,7 @@ abstract class BCodeTypes extends BCodeIdiomatic { if (opt != null) { return opt } - - val key = brefType(csym.javaBinaryName.toTypeName) + val key = new ClassBType(csym.javaBinaryName.toTypeName) assert(key.isNonSpecial || isCompilingStdLib, s"Not a class to track: ${csym.fullName}") // TODO accomodate the fix for SI-5031 of https://github.com/scala/scala/commit/0527b2549bcada2fda2201daa630369b377d0877 @@ -396,7 +393,7 @@ abstract class BCodeTypes extends BCodeIdiomatic { /* * must-single-thread */ - private def buildExemplar(key: BType, csym: Symbol): Tracked = { + private def buildExemplar(key: ClassBType, csym: Symbol): Tracked = { val sc = if (csym.isImplClass) definitions.ObjectClass else csym.superClass @@ -465,29 +462,30 @@ abstract class BCodeTypes extends BCodeIdiomatic { if ((b == jlCloneableReference) || (b == jioSerializableReference) || (b == AnyRefReference)) { true } - else if (b.isArray) { conforms(a.getComponentType, b.getComponentType) } + else if (b.isArray) { conforms(a.asArrayBType.componentType, // TODO @lry change to pattern match, get rid of casts + b.asArrayBType.componentType) } else { false } } else if (a.isBoxed) { // may be null if (b.isBoxed) { a == b } else if (b == AnyRefReference) { true } - else if (!(b.hasObjectSort)) { false } + else if (!(b.isClass)) { false } else { exemplars.get(a).isSubtypeOf(b) } // e.g., java/lang/Double conforms to java/lang/Number } else if (a.isNullType) { // known to be null if (b.isNothingType) { false } - else if (b.isValueType) { false } + else if (b.isPrimitive) { false } else { true } } else if (a.isNothingType) { // known to be Nothing true } - else if (a.isUnitType) { - b.isUnitType + else if (a == UNIT) { + b == UNIT } - else if (a.hasObjectSort) { // may be null + else if (a.isClass) { // may be null if (a.isNothingType) { true } - else if (b.hasObjectSort) { exemplars.get(a).isSubtypeOf(b) } + else if (b.isClass) { exemplars.get(a).isSubtypeOf(b) } else if (b.isArray) { a.isNullType } // documentation only, because `if(a.isNullType)` (above) covers this case already. else { false } } @@ -495,8 +493,8 @@ abstract class BCodeTypes extends BCodeIdiomatic { def msg = s"(a: $a, b: $b)" - assert(a.isNonUnitValueType, s"a isn't a non-Unit value type. $msg") - assert(b.isValueType, s"b isn't a value type. $msg") + assert(a.isNonVoidPrimitiveType, s"a isn't a non-Unit value type. $msg") + assert(b.isPrimitive, s"b isn't a value type. $msg") (a eq b) || (a match { case BOOL | BYTE | SHORT | CHAR => b == INT || b == LONG // TODO Actually, BOOL does NOT conform to LONG. Even with adapt(). @@ -510,7 +508,7 @@ abstract class BCodeTypes extends BCodeIdiomatic { * can-multi-thread */ def maxValueType(a: BType, other: BType): BType = { - assert(a.isValueType, "maxValueType() is defined only for 1st arg valuetypes (2nd arg doesn't matter).") + assert(a.isPrimitive, "maxValueType() is defined only for 1st arg valuetypes (2nd arg doesn't matter).") def uncomparable: Nothing = { abort(s"Uncomparable BTypes: $a with $other") @@ -526,30 +524,30 @@ abstract class BCodeTypes extends BCodeIdiomatic { case BOOL => uncomparable case BYTE => - if (other == CHAR) INT + if (other == CHAR) INT else if (other.isNumericType) other else uncomparable case SHORT => other match { - case BYTE => SHORT - case CHAR => INT + case BYTE => SHORT + case CHAR => INT case INT | LONG | FLOAT | DOUBLE => other - case _ => uncomparable + case _ => uncomparable } case CHAR => other match { - case BYTE | SHORT => INT + case BYTE | SHORT => INT case INT | LONG | FLOAT | DOUBLE => other - case _ => uncomparable + case _ => uncomparable } case INT => other match { case BYTE | SHORT | CHAR => INT case LONG | FLOAT | DOUBLE => other - case _ => uncomparable + case _ => uncomparable } case LONG => @@ -558,7 +556,7 @@ abstract class BCodeTypes extends BCodeIdiomatic { else uncomparable case FLOAT => - if (other == DOUBLE) DOUBLE + if (other == DOUBLE) DOUBLE else if (other.isNumericType) FLOAT else uncomparable @@ -575,18 +573,18 @@ abstract class BCodeTypes extends BCodeIdiomatic { * can-multi-thread */ final def maxType(a: BType, other: BType): BType = { - if (a.isValueType) { maxValueType(a, other) } + if (a.isPrimitive) { maxValueType(a, other) } else { if (a.isNothingType) return other; if (other.isNothingType) return a; if (a == other) return a; // Approximate `lub`. The common type of two references is always AnyRef. // For 'real' least upper bound wrt to subclassing use method 'lub'. - assert(a.isArray || a.isBoxed || a.hasObjectSort, s"This is not a valuetype and it's not something else, what is it? $a") + assert(a.isArray || a.isBoxed || a.isClass, s"This is not a valuetype and it's not something else, what is it? $a") // TODO For some reason, ICode thinks `REFERENCE(...).maxType(BOXED(whatever))` is `uncomparable`. Here, that has maxType AnyRefReference. // BTW, when swapping arguments, ICode says BOXED(whatever).maxType(REFERENCE(...)) == AnyRefReference, so I guess the above was an oversight in REFERENCE.maxType() - if (other.isRefOrArrayType) { AnyRefReference } - else { abort(s"Uncomparable BTypes: $a with $other") } + if (other.isRef) { AnyRefReference } + else { abort(s"Uncomparable BTypes: $a with $other") } } } @@ -598,7 +596,7 @@ abstract class BCodeTypes extends BCodeIdiomatic { * can-multi-thread */ def isPartialFunctionType(t: BType): Boolean = { - (t.hasObjectSort) && exemplars.get(t).isSubtypeOf(PartialFunctionReference) + (t.isClass) && exemplars.get(t).isSubtypeOf(PartialFunctionReference) } /* @@ -607,7 +605,7 @@ abstract class BCodeTypes extends BCodeIdiomatic { * can-multi-thread */ def isFunctionType(t: BType): Boolean = { - if (!t.hasObjectSort) return false + if (!t.isClass) return false var idx = 0 val et: Tracked = exemplars.get(t) while (idx <= definitions.MaxFunctionArity) { diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala index 0c5dcd2908fc..e6b2136be2bb 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala @@ -4,6 +4,8 @@ package backend.jvm import scala.collection.immutable import scala.annotation.switch import scala.tools.asm +import asm.Opcodes +import scala.collection.mutable.ListBuffer /** * BTypes is a backend component that defines the class BType, a number of basic instances and @@ -30,675 +32,346 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { */ def createNewName(s: String): BTypeName - /** - * Creates a BType for the class, interface or array descriptor `iname`. - * - * must-single-thread - */ - def brefType(iname: String): BType = brefType(createNewName(iname)) - - /** - * Creates a BType for the class, interface or array descriptor `iname`. - * - * can-multi-thread - */ - def brefType(iname: BTypeName): BType = BType.getObjectType(iname.start, iname.length) - - /** - * TODO @lry : make members private to BType, move those used outside into the BTypes component - */ - object BType { - // ------------- sorts ------------- - - final val VOID = asm.Type.VOID - final val BOOLEAN = asm.Type.BOOLEAN - final val CHAR = asm.Type.CHAR - final val BYTE = asm.Type.BYTE - final val SHORT = asm.Type.SHORT - final val INT = asm.Type.INT - final val FLOAT = asm.Type.FLOAT - final val LONG = asm.Type.LONG - final val DOUBLE = asm.Type.DOUBLE - final val ARRAY = asm.Type.ARRAY - final val OBJECT = asm.Type.OBJECT - final val METHOD = asm.Type.METHOD - - // ------------- primitive types ------------- - - // magic shifted numbers: see comment on class BType. This has been copied 1:1 from asm.Type. - - val VOID_TYPE = new BType(VOID, ('V' << 24) | (5 << 16) | (0 << 8) | 0, 1) - val BOOLEAN_TYPE = new BType(BOOLEAN, ('Z' << 24) | (0 << 16) | (5 << 8) | 1, 1) - val CHAR_TYPE = new BType(CHAR, ('C' << 24) | (0 << 16) | (6 << 8) | 1, 1) - val BYTE_TYPE = new BType(BYTE, ('B' << 24) | (0 << 16) | (5 << 8) | 1, 1) - val SHORT_TYPE = new BType(SHORT, ('S' << 24) | (0 << 16) | (7 << 8) | 1, 1) - val INT_TYPE = new BType(INT, ('I' << 24) | (0 << 16) | (0 << 8) | 1, 1) - val FLOAT_TYPE = new BType(FLOAT, ('F' << 24) | (2 << 16) | (2 << 8) | 1, 1) - val LONG_TYPE = new BType(LONG, ('J' << 24) | (1 << 16) | (1 << 8) | 2, 1) - val DOUBLE_TYPE = new BType(DOUBLE, ('D' << 24) | (3 << 16) | (3 << 8) | 2, 1) - - /* - * Returns the Java type corresponding to the given type descriptor. - * - * @param off the offset of this descriptor in the chrs buffer. - * @return the Java type corresponding to the given type descriptor. - * - * can-multi-thread - */ - def getType(off: Int): BType = { - var len = 0 - chrs(off) match { - case 'V' => VOID_TYPE - case 'Z' => BOOLEAN_TYPE - case 'C' => CHAR_TYPE - case 'B' => BYTE_TYPE - case 'S' => SHORT_TYPE - case 'I' => INT_TYPE - case 'F' => FLOAT_TYPE - case 'J' => LONG_TYPE - case 'D' => DOUBLE_TYPE - case '[' => - len = 1 - while (chrs(off + len) == '[') { - len += 1 - } - if (chrs(off + len) == 'L') { - len += 1 - while (chrs(off + len) != ';') { - len += 1 - } - } - new BType(ARRAY, off, len + 1) - case 'L' => - len = 1 - while (chrs(off + len) != ';') { - len += 1 - } - new BType(OBJECT, off + 1, len - 1) - // case '(': - case _ => - assert(chrs(off) == '(') - var resPos = off + 1 - while (chrs(resPos) != ')') { resPos += 1 } - val resType = getType(resPos + 1) - val len = resPos - off + 1 + resType.len - new BType( - METHOD, - off, - if (resType.hasObjectSort) { - len + 2 // "+ 2" accounts for the "L ... ;" in a descriptor for a non-array reference. - } else { - len - } - ) - } + /*sealed*/ trait BType { // Not sealed for now due to SI-8546 + final override def toString: String = this match { + case UNIT => "V" + case BOOL => "Z" + case CHAR => "C" + case BYTE => "B" + case SHORT => "S" + case INT => "I" + case FLOAT => "F" + case LONG => "J" + case DOUBLE => "D" + case c @ ClassBType(_, _) => "L" + c.internalName + ";" + case ArrayBType(component) => "[" + component + case MethodBType(args, res) => "(" + args.mkString + ")" + res } - /* Params denote an internal name. - * can-multi-thread + /** + * @return The Java descriptor of this type. Examples: + * - int: I + * - java.lang.String: Ljava/lang/String; + * - int[]: [I + * - Object m(String s, double d): (Ljava/lang/String;D)Ljava/lang/Object; */ - def getObjectType(index: Int, length: Int): BType = { - val sort = if (chrs(index) == '[') ARRAY else OBJECT - new BType(sort, index, length) - } + final def descriptor = toString - /* - * @param methodDescriptor a method descriptor. - * - * must-single-thread + /** + * @return 0 for void, 2 for long and double, 1 otherwise */ - def getMethodType(methodDescriptor: String): BType = { - val n = createNewName(methodDescriptor) - new BType(BType.METHOD, n.start, n.length) // TODO assert isValidMethodDescriptor + final def size: Int = this match { + case UNIT => 0 + case LONG | DOUBLE => 2 + case _ => 1 } - /* - * Returns the Java method type corresponding to the given argument and return types. - * - * @param returnType the return type of the method. - * @param argumentTypes the argument types of the method. - * @return the Java type corresponding to the given argument and return types. - * - * must-single-thread - */ - def getMethodType(returnType: BType, argumentTypes: Array[BType]): BType = { - val n = createNewName(getMethodDescriptor(returnType, argumentTypes)) - new BType(BType.METHOD, n.start, n.length) + final def isPrimitive: Boolean = this.isInstanceOf[PrimitiveBType] + final def isRef: Boolean = this.isInstanceOf[RefBType] + final def isArray: Boolean = this.isInstanceOf[ArrayBType] + final def isClass: Boolean = this.isInstanceOf[ClassBType] + final def isMethod: Boolean = this.isInstanceOf[MethodBType] + + final def isNonVoidPrimitiveType = isPrimitive && this != UNIT + // TODO @lry should also include !isMethod in isNonSpecial? in this case it would be equivalent to isClass, so we could get rid of it. + final def isNonSpecial = !isPrimitive && !isArray && !isPhantomType + final def isNullType = this == RT_NULL || this == CT_NULL + final def isNothingType = this == RT_NOTHING || this == CT_NOTHING + final def isPhantomType = isNullType || isNothingType + + final def isBoxed = this match { + case BOXED_UNIT | BOXED_BOOLEAN | BOXED_CHAR | + BOXED_BYTE | BOXED_SHORT | BOXED_INT | + BOXED_FLOAT | BOXED_LONG | BOXED_DOUBLE => true + case _ => false } - /* - * Returns the Java types corresponding to the argument types of method descriptor whose first argument starts at idx0. - * - * @param idx0 index into chrs of the first argument (after the '('). - * @return the Java types corresponding to the argument types of the given method descriptor. - * - * can-multi-thread + final def isIntSizedType = this == BOOL || this == CHAR || this == BYTE || + this == SHORT || this == INT + final def isIntegralType = this == INT || this == BYTE || this == LONG || + this == CHAR || this == SHORT + final def isRealType = this == FLOAT || this == DOUBLE + final def isNumericType = isIntegralType || isRealType + final def isWideType = size == 2 + + /** + * See documentation of [[typedOpcode]]. + * The numbers are taken from asm.Type.VOID_TYPE ff., the values are those shifted by << 8. */ - private def getArgumentTypes(idx0: Int): Array[BType] = { - assert(chrs(idx0 - 1) == '(', "doesn't look like a method descriptor.") - val args = new Array[BType](getArgumentCount(idx0)) - var off = idx0 - var size = 0 - while (chrs(off) != ')') { - args(size) = getType(off) - off += args(size).len - if (args(size).sort == OBJECT) { off += 2 } // account for 'L' and ';' - // debug: assert("LVZBSCIJFD[)".contains(chrs(off))) - size += 1 - } - // debug: var check = 0; while (check < args.length) { assert(args(check) != null); check += 1 } - args + private def loadStoreOpcodeOffset: Int = this match { + case UNIT | INT => 0 + case BOOL | BYTE => 5 + case CHAR => 6 + case SHORT => 7 + case FLOAT => 2 + case LONG => 1 + case DOUBLE => 3 + case _ => 4 } - /* - * Returns the number of argument types of this method type, whose first argument starts at idx0. - * - * @param idx0 index into chrs of the first argument. - * @return the number of argument types of this method type. - * - * can-multi-thread + /** + * See documentation of [[typedOpcode]]. + * The numbers are taken from asm.Type.VOID_TYPE ff., the values are those shifted by << 16. */ - private def getArgumentCount(idx0: Int): Int = { - assert(chrs(idx0 - 1) == '(', "doesn't look like a method descriptor.") - var off = idx0 - var size = 0 - var keepGoing = true - while (keepGoing) { - val car = chrs(off) - off += 1 - if (car == ')') { - keepGoing = false - } else if (car == 'L') { - while (chrs(off) != ';') { off += 1 } - off += 1 - size += 1 - } else if (car != '[') { - size += 1 - } - } - - size + private def typedOpcodeOffset: Int = this match { + case UNIT => 5 + case BOOL | CHAR | BYTE | SHORT | INT => 0 + case FLOAT => 2 + case LONG => 1 + case DOUBLE => 3 + case _ => 4 } - /* - * Returns the Java type corresponding to the return type of the given - * method descriptor. - * - * @param methodDescriptor a method descriptor. - * @return the Java type corresponding to the return type of the given method descriptor. + /** + * Some JVM opcodes have typed variants. This method returns the correct opcode according to + * the type. * - * must-single-thread + * @param opcode A JVM instruction opcode. This opcode must be one of ILOAD, ISTORE, IALOAD, + * IASTORE, IADD, ISUB, IMUL, IDIV, IREM, INEG, ISHL, ISHR, IUSHR, IAND, IOR + * IXOR and IRETURN. + * @return The opcode adapted to this java type. For example, if this type is `float` and + * `opcode` is `IRETURN`, this method returns `FRETURN`. */ - def getReturnType(methodDescriptor: String): BType = { - val n = createNewName(methodDescriptor) - val delta = n.pos(')') // `delta` is relative to the Name's zero-based start position, not a valid index into chrs. - assert(delta < n.length, s"not a valid method descriptor: $methodDescriptor") - getType(n.start + delta + 1) + final def typedOpcode(opcode: Int): Int = { + if (opcode == Opcodes.IALOAD || opcode == Opcodes.IASTORE) + opcode + loadStoreOpcodeOffset + else + opcode + typedOpcodeOffset } - /* - * Returns the descriptor corresponding to the given argument and return types. - * Note: no BType is created here for the resulting method descriptor, - * if that's desired the invoker is responsible for that. + /** + * The asm.Type corresponding to this BType. * - * @param returnType the return type of the method. - * @param argumentTypes the argument types of the method. - * @return the descriptor corresponding to the given argument and return types. + * Note about asm.Type.getObjectType (*): For class types, the method expects the internal + * name, i.e. without the surrounding 'L' and ';'. For array types on the other hand, the + * method expects a full descriptor, for example "[Ljava/lang/String;". * - * can-multi-thread + * See method asm.Type.getType that creates a asm.Type from a type descriptor + * - for an OBJECT type, the 'L' and ';' are not part of the range of the created Type + * - for an ARRAY type, the full descriptor is part of the range */ - def getMethodDescriptor( - returnType: BType, - argumentTypes: Array[BType]): String = - { - val buf = new StringBuffer() - buf.append('(') - var i = 0 - while (i < argumentTypes.length) { - argumentTypes(i).getDescriptor(buf) - i += 1 - } - buf.append(')') - returnType.getDescriptor(buf) - buf.toString() + def toASMType: asm.Type = this match { + case UNIT => asm.Type.VOID_TYPE + case BOOL => asm.Type.BOOLEAN_TYPE + case CHAR => asm.Type.CHAR_TYPE + case BYTE => asm.Type.BYTE_TYPE + case SHORT => asm.Type.SHORT_TYPE + case INT => asm.Type.INT_TYPE + case FLOAT => asm.Type.FLOAT_TYPE + case LONG => asm.Type.LONG_TYPE + case DOUBLE => asm.Type.DOUBLE_TYPE + case c @ ClassBType(_, _) => asm.Type.getObjectType(c.internalName) // (*) + case a @ ArrayBType(_) => asm.Type.getObjectType(a.descriptor) + case m @ MethodBType(_, _) => asm.Type.getMethodType(m.descriptor) } - } // end of object BType - - /** - * Based on ASM's Type class. Namer's chrs is used in this class for the same purposes as the - * `buf` char array in asm.Type. - * - * @param sort One of BType.VOID ... BType.METHOD - * - * @param off For array, object and method types, the offset of the type description in chrs. - * For primitive types, the `off` field contains - * - at byte 0 (& 0xff): the lenght, 0 for void, 2 for long/double, 1 otherwise - * - at byte 1 (& 0xff00): the Opcode offset for the corresponding xALOAD / xSTORE - * instruction. Example: Opcodes.IALOAD is 46, to load a boolean or a byte the - * necessary Opcode.BALOAD is 51, therefore the offset value is 5. - * - at byte 2 (& 0xff0000): the Opcode offset for other instructions (xLOAD, - * xSTORE, xADD, etc). See method BType#getOpcode. - * - at byte 3 (& 0xff000000): the descriptor ('V' for void, etc) - * For array types, the description starts with one or more '[' - * - * @param len The length of the type description - * - 1 for primitive types - * - For array, object and method types, the number of characters in chrs. - * Note: for array and method types, '[' and '(' and ')' are stored in the array - * and included in the length, for example "[Ljava/lang/Object;" or "(I)L...;" - * For object types, the leading 'L' and trailing ';' are not stored in the array - * and therefore excluded from the length, for example "java/lang/Object". - * - * All methods of this classs can-multi-thread - */ - final class BType(val sort: Int, val off: Int, val len: Int) { - /* - * can-multi-thread - */ - def toASMType: asm.Type = (sort: @switch) match { - case BType.VOID => asm.Type.VOID_TYPE - case BType.BOOLEAN => asm.Type.BOOLEAN_TYPE - case BType.CHAR => asm.Type.CHAR_TYPE - case BType.BYTE => asm.Type.BYTE_TYPE - case BType.SHORT => asm.Type.SHORT_TYPE - case BType.INT => asm.Type.INT_TYPE - case BType.FLOAT => asm.Type.FLOAT_TYPE - case BType.LONG => asm.Type.LONG_TYPE - case BType.DOUBLE => asm.Type.DOUBLE_TYPE - case BType.ARRAY | - BType.OBJECT => asm.Type.getObjectType(getInternalName) - case BType.METHOD => asm.Type.getMethodType(getDescriptor) - } + def asRefBType : RefBType = this.asInstanceOf[RefBType] + def asArrayBType: ArrayBType = this.asInstanceOf[ArrayBType] + def asClassBType: ClassBType = this.asInstanceOf[ClassBType] + } - /* - * Returns the number of dimensions of this array type. This method should - * only be used for an array type. - * - * @return the number of dimensions of this array type. - * - * can-multi-thread + object BType { + /** + * @param chars The character array containing the descriptor + * @param start The position where the descriptor starts + * @return The BType and the index of the first character after the consumed descriptor */ - def getDimensions: Int = { - assert(isArray, s"getDimensions on non-array type $this") - var i = 1 - while (chrs(off + i) == '[') { - i += 1 + private[BTypes] def fromNonMethodDescriptor(chars: Array[Char], start: Int): (BType, Int) = { + chars(start) match { + case 'L' => + var i = start + while (chars(i) != ';') { i += 1 } + // Example: chars = "IILpkg/Cls;I" + // ^ ^ + // start=2 i=10 + // `start + 1` to exclude the 'L', `i - start - 1` excludes the ';' + (new ClassBType(new String(chars, start + 1, i - start - 1)), i + 1) + case '[' => + val (res, next) = fromNonMethodDescriptor(chars, start + 1) + (ArrayBType(res), next) + case 'V' => (UNIT, start + 1) + case 'Z' => (BOOL, start + 1) + case 'C' => (CHAR, start + 1) + case 'B' => (BYTE, start + 1) + case 'S' => (SHORT, start + 1) + case 'I' => (INT, start + 1) + case 'F' => (FLOAT, start + 1) + case 'J' => (LONG, start + 1) + case 'D' => (DOUBLE, start + 1) } - i - } - - /* - * Returns the (ultimate) element type of this array type. - * This method should only be used for an array type. - * - * @return Returns the type of the elements of this array type. - * - * can-multi-thread - */ - def getElementType: BType = { - assert(isArray, s"getElementType on non-array type $this") - BType.getType(off + getDimensions) } + } - /* - * Element vs. Component type of an array: - * Quoting from the JVMS, Sec. 2.4 "Reference Types and Values" - * - * An array type consists of a component type with a single dimension (whose - * length is not given by the type). The component type of an array type may itself be - * an array type. If, starting from any array type, one considers its component type, - * and then (if that is also an array type) the component type of that type, and so on, - * eventually one must reach a component type that is not an array type; this is called - * the element type of the array type. The element type of an array type is necessarily - * either a primitive type, or a class type, or an interface type. - * - */ + sealed trait PrimitiveBType extends BType - /* The type of items this array holds. - * - * can-multi-thread - */ - def getComponentType: BType = { - assert(isArray, s"Asked for the component type of a non-array type: $this") - BType.getType(off + 1) - } + case object UNIT extends PrimitiveBType + case object BOOL extends PrimitiveBType + case object CHAR extends PrimitiveBType + case object BYTE extends PrimitiveBType + case object SHORT extends PrimitiveBType + case object INT extends PrimitiveBType + case object FLOAT extends PrimitiveBType + case object LONG extends PrimitiveBType + case object DOUBLE extends PrimitiveBType - /* - * Returns the internal name of the class corresponding to this object or - * array type. The internal name of a class is its fully qualified name (as - * returned by Class.getName(), where '.' are replaced by '/'. This method - * should only be used for an object or array type. + sealed trait RefBType extends BType { + /** + * The class or array type of this reference type. Used for ANEWARRAY, MULTIANEWARRAY, + * INSTANCEOF and CHECKCAST instructions. * - * @return the internal name of the class corresponding to this object type. + * In contrast to the descriptor, this string does not contain the surrounding 'L' and ';' for + * class types, for example "java/lang/String". + * However, for array types, the full descriptor is used, for example "[Ljava/lang/String;". * - * can-multi-thread + * This can be verified for example using javap or ASMifier. */ - def getInternalName: String = { - assert(isRefOrArrayType, s"getInternalName on non-object, non-array type $this") - new String(chrs, off, len) - } - - /* - * @return the suffix of the internal name until the last '/' (if '/' present), internal name otherwise. - * - * can-multi-thread - */ - def getSimpleName: String = { - assert(hasObjectSort, s"getSimpleName on non-object $this") - val iname = getInternalName - val idx = iname.lastIndexOf('/') - if (idx == -1) iname - else iname.substring(idx + 1) - } - - /* - * Returns the argument types of methods of this type. - * This method should only be used for method types. - * - * @return the argument types of methods of this type. - * - * can-multi-thread - */ - def getArgumentTypes: Array[BType] = { - assert(sort == BType.METHOD, s"getArgumentTypes on non-method $this") - BType.getArgumentTypes(off + 1) - } - - /* - * Returns the return type of methods of this type. - * This method should only be used for method types. - * - * @return the return type of methods of this type. - * - * can-multi-thread - */ - def getReturnType: BType = { - assert(sort == BType.METHOD, s"getReturnType on non-method $this") - var resPos = off + 1 - while (chrs(resPos) != ')') { resPos += 1 } - BType.getType(resPos + 1) - } - - // ------------------------------------------------------------------------ - // Inspector methods - // ------------------------------------------------------------------------ - - def isPrimitiveOrVoid = (sort < BType.ARRAY) // can-multi-thread - def isValueType = (sort < BType.ARRAY) // can-multi-thread - def isArray = (sort == BType.ARRAY) // can-multi-thread - def isUnitType = (sort == BType.VOID) // can-multi-thread - - /* - * Unlike for ICode's REFERENCE, isBoxedType(t) implies isReferenceType(t) - * Also, `isReferenceType(RT_NOTHING) == true` , similarly for RT_NULL. - * Use isNullType() , isNothingType() to detect Nothing and Null. - * - * can-multi-thread - */ - def hasObjectSort = (sort == BType.OBJECT) - - def isRefOrArrayType = { hasObjectSort || isArray } // can-multi-thread - def isNonUnitValueType = { isValueType && !isUnitType } // can-multi-thread - - def isNonSpecial = { !isValueType && !isArray && !isPhantomType } // can-multi-thread - def isNothingType = { (this == RT_NOTHING) || (this == CT_NOTHING) } // can-multi-thread - def isNullType = { (this == RT_NULL) || (this == CT_NULL) } // can-multi-thread - def isPhantomType = { isNothingType || isNullType } // can-multi-thread - - /* - * can-multi-thread - */ - def isBoxed = { - this match { - case BOXED_UNIT | BOXED_BOOLEAN | BOXED_CHAR | - BOXED_BYTE | BOXED_SHORT | BOXED_INT | - BOXED_FLOAT | BOXED_LONG | BOXED_DOUBLE - => true - case _ - => false - } + def classOrArrayType: String = this match { + case c: ClassBType => c.internalName + case a: ArrayBType => a.descriptor } + } - /* On the JVM, - * BOOL, BYTE, CHAR, SHORT, and INT - * are like Ints for the purpose of lub calculation. + /** + * Class or Interface type. + * + * Classes are represented using their name as a slice of the `chrs` array. This representation is + * efficient because the JVM class name is initially created using `classSymbol.javaBinaryName`. + * This already adds the necessary string to the `chrs` array, so it makes sense to reuse the same + * name table in the backend. + * + * Not a case class because that would expose the (Int, Int) constructor (didn't find a way to + * make it private, also the factory in the companion). + */ + class ClassBType private(val offset: Int, val length: Int) extends RefBType { + /** + * Construct a ClassBType for a given (intenred) class name. * - * can-multi-thread + * @param n The class name as a slice of the `chrs` array, without the surrounding 'L' and ';'. + * Note that `classSymbol.javaBinaryName` returns exactly such a name. */ - def isIntSizedType = { - (sort : @switch) match { - case BType.BOOLEAN | BType.CHAR | - BType.BYTE | BType.SHORT | BType.INT - => true - case _ - => false - } - } + def this(n: BTypeName) = this(n.start, n.length) - /* On the JVM, similar to isIntSizedType except that BOOL isn't integral while LONG is. + /** + * Construct a ClassBType for a given java class name. * - * can-multi-thread + * @param s A class name of the form "java/lang/String", without the surrounding 'L' and ';'. */ - def isIntegralType = { - (sort : @switch) match { - case BType.CHAR | - BType.BYTE | BType.SHORT | BType.INT | - BType.LONG - => true - case _ - => false - } - } + def this(s: String) = this(createNewName(s)) - /* On the JVM, FLOAT and DOUBLE. - * - * can-multi-thread + /** + * The internal name of a class is the string returned by java.lang.Class.getName, with all '.' + * replaced by '/'. For example "java/lang/String". */ - def isRealType = { (sort == BType.FLOAT ) || (sort == BType.DOUBLE) } + def internalName: String = new String(chrs, offset, length) - def isNumericType = (isIntegralType || isRealType) // can-multi-thread - - /* Is this type a category 2 type in JVM terms? (ie, is it LONG or DOUBLE?) - * - * can-multi-thread + /** + * @return The class name without the package prefix */ - def isWideType = (getSize == 2) + def simpleName: String = internalName.split("/").last - // ------------------------------------------------------------------------ - // Conversion to type descriptors - // ------------------------------------------------------------------------ - - /* - * @return the descriptor corresponding to this Java type. - * - * can-multi-thread + /** + * Custom equals / hashCode are needed because this is not a case class. */ - def getDescriptor: String = { - val buf = new StringBuffer() - getDescriptor(buf) - buf.toString() + override def equals(o: Any): Boolean = (this eq o.asInstanceOf[Object]) || (o match { + case ClassBType(`offset`, `length`) => true + case _ => false + }) + + override def hashCode: Int = { + import scala.runtime.Statics + var acc: Int = -889275714 + acc = Statics.mix(acc, offset) + acc = Statics.mix(acc, length) + Statics.finalizeHash(acc, 2) } + } - /* - * Appends the descriptor corresponding to this Java type to the given string buffer. - * - * @param buf the string buffer to which the descriptor must be appended. - * - * can-multi-thread - */ - private def getDescriptor(buf: StringBuffer) { - if (isPrimitiveOrVoid) { - // descriptor is in byte 3 of 'off' for primitive types (buf == null) - buf.append(((off & 0xFF000000) >>> 24).asInstanceOf[Char]) - } else if (sort == BType.OBJECT) { - buf.append('L') - buf.append(chrs, off, len) - buf.append(';') - } else { // sort == ARRAY || sort == METHOD - buf.append(chrs, off, len) - } - } + object ClassBType { + def apply(n: BTypeName): ClassBType = new ClassBType(n) + def apply(s: String): ClassBType = new ClassBType(s) - // ------------------------------------------------------------------------ - // Corresponding size and opcodes - // ------------------------------------------------------------------------ + def unapply(c: ClassBType): Option[(Int, Int)] = + if (c == null) None + else Some((c.offset, c.length)) + } - /* - * Returns the size of values of this type. - * This method must not be used for method types. - * - * @return the size of values of this type, i.e., 2 for long and - * double, 0 for void and 1 otherwise. - * - * can-multi-thread - */ - def getSize: Int = { - // the size is in byte 0 of 'off' for primitive types (buf == null) - if (isPrimitiveOrVoid) (off & 0xFF) else 1 + case class ArrayBType(componentType: BType) extends RefBType { + def dimension: Int = componentType match { + case a: ArrayBType => 1 + a.dimension + case _ => 1 } - /* - * Returns a JVM instruction opcode adapted to this Java type. This method - * must not be used for method types. - * - * @param opcode a JVM instruction opcode. This opcode must be one of ILOAD, - * ISTORE, IALOAD, IASTORE, IADD, ISUB, IMUL, IDIV, IREM, INEG, ISHL, - * ISHR, IUSHR, IAND, IOR, IXOR and IRETURN. - * @return an opcode that is similar to the given opcode, but adapted to - * this Java type. For example, if this type is float and - * opcode is IRETURN, this method returns FRETURN. - * - * can-multi-thread - */ - def getOpcode(opcode: Int): Int = { - import asm.Opcodes - if (opcode == Opcodes.IALOAD || opcode == Opcodes.IASTORE) { - // the offset for IALOAD or IASTORE is in byte 1 of 'off' for - // primitive types (buf == null) - opcode + (if (isPrimitiveOrVoid) (off & 0xFF00) >> 8 else 4) - } else { - // the offset for other instructions is in byte 2 of 'off' for - // primitive types (buf == null) - opcode + (if (isPrimitiveOrVoid) (off & 0xFF0000) >> 16 else 4) - } + def elementType: BType = componentType match { + case a: ArrayBType => a.elementType + case t => t } + } - // ------------------------------------------------------------------------ - // Equals, hashCode and toString - // ------------------------------------------------------------------------ + case class MethodBType(argumentTypes: List[BType], returnType: BType) extends BType { + private def this(types: (List[BType], BType)) = this(types._1, types._2) + def this(descriptor: String) = this(MethodBType.decomposeMethodDescriptor(descriptor)) + } - /* - * Tests if the given object is equal to this type. - * - * @param o the object to be compared to this type. - * @return true if the given object is equal to this type. - * - * can-multi-thread - */ - override def equals(o: Any): Boolean = { - if (!(o.isInstanceOf[BType])) { - return false - } - val t = o.asInstanceOf[BType] - if (this eq t) { - return true - } - if (sort != t.sort) { - return false - } - if (sort >= BType.ARRAY) { - if (len != t.len) { - return false - } - // sort checked already - if (off == t.off) { - return true - } - var i = 0 - while (i < len) { - if (chrs(off + i) != chrs(t.off + i)) { - return false - } - i += 1 - } - // If we reach here, we could update the largest of (this.off, t.off) to match the other, so as to simplify future == comparisons. - // But that would require a var rather than val. + object MethodBType { + private def decomposeMethodDescriptor(descriptor: String): (List[BType], BType) = { + val chars = descriptor.toCharArray + assert(chars(0) == '(', s"Not a valid method descriptor: $descriptor") + var i = 1 + val argTypes = new ListBuffer[BType] + while (chars(i) != ')') { + val (argType, next) = BType.fromNonMethodDescriptor(chars, i) + argTypes += argType + i = next } - true + val (resType, _) = BType.fromNonMethodDescriptor(chars, i + 1) // `i + 1` to skip the ')' + (argTypes.toList, resType) } - - /* - * @return a hash code value for this type. - * - * can-multi-thread - */ - override def hashCode(): Int = { - var hc = 13 * sort - if (sort >= BType.ARRAY) { - var i = off - val end = i + len - while (i < end) { - hc = 17 * (hc + chrs(i)) - i += 1 - } - } - hc + def apply(descriptor: String) = { + val (argTypes, resType) = decomposeMethodDescriptor(descriptor) + new MethodBType(argTypes, resType) } - - /* - * @return the descriptor of this type. - * - * can-multi-thread - */ - override def toString: String = getDescriptor } - val UNIT = BType.VOID_TYPE - val BOOL = BType.BOOLEAN_TYPE - val CHAR = BType.CHAR_TYPE - val BYTE = BType.BYTE_TYPE - val SHORT = BType.SHORT_TYPE - val INT = BType.INT_TYPE - val LONG = BType.LONG_TYPE - val FLOAT = BType.FLOAT_TYPE - val DOUBLE = BType.DOUBLE_TYPE - - val BOXED_UNIT = brefType("java/lang/Void") - val BOXED_BOOLEAN = brefType("java/lang/Boolean") - val BOXED_BYTE = brefType("java/lang/Byte") - val BOXED_SHORT = brefType("java/lang/Short") - val BOXED_CHAR = brefType("java/lang/Character") - val BOXED_INT = brefType("java/lang/Integer") - val BOXED_LONG = brefType("java/lang/Long") - val BOXED_FLOAT = brefType("java/lang/Float") - val BOXED_DOUBLE = brefType("java/lang/Double") + val BOXED_UNIT = ClassBType("java/lang/Void") + val BOXED_BOOLEAN = ClassBType("java/lang/Boolean") + val BOXED_BYTE = ClassBType("java/lang/Byte") + val BOXED_SHORT = ClassBType("java/lang/Short") + val BOXED_CHAR = ClassBType("java/lang/Character") + val BOXED_INT = ClassBType("java/lang/Integer") + val BOXED_LONG = ClassBType("java/lang/Long") + val BOXED_FLOAT = ClassBType("java/lang/Float") + val BOXED_DOUBLE = ClassBType("java/lang/Double") /* - * RT_NOTHING and RT_NULL exist at run-time only. - * They are the bytecode-level manifestation (in method signatures only) of what shows up as NothingClass resp. NullClass in Scala ASTs. - * Therefore, when RT_NOTHING or RT_NULL are to be emitted, - * a mapping is needed: the internal names of NothingClass and NullClass can't be emitted as-is. + * RT_NOTHING and RT_NULL exist at run-time only. They are the bytecode-level manifestation (in + * method signatures only) of what shows up as NothingClass resp. NullClass in Scala ASTs. + * + * Therefore, when RT_NOTHING or RT_NULL are to be emitted, a mapping is needed: the internal + * names of NothingClass and NullClass can't be emitted as-is. */ - val RT_NOTHING = brefType("scala/runtime/Nothing$") - val RT_NULL = brefType("scala/runtime/Null$") - val CT_NOTHING = brefType("scala/Nothing") - val CT_NULL = brefType("scala/Null") - - val srBooleanRef = brefType("scala/runtime/BooleanRef") - val srByteRef = brefType("scala/runtime/ByteRef") - val srCharRef = brefType("scala/runtime/CharRef") - val srIntRef = brefType("scala/runtime/IntRef") - val srLongRef = brefType("scala/runtime/LongRef") - val srFloatRef = brefType("scala/runtime/FloatRef") - val srDoubleRef = brefType("scala/runtime/DoubleRef") - - /* Map from type kinds to the Java reference types. - * Useful when pushing class literals onto the operand stack (ldc instruction taking a class literal). - * @see Predef.classOf - * @see genConstant() + val RT_NOTHING = ClassBType("scala/runtime/Nothing$") + val RT_NULL = ClassBType("scala/runtime/Null$") + val CT_NOTHING = ClassBType("scala/Nothing") + val CT_NULL = ClassBType("scala/Null") + + val srBooleanRef = ClassBType("scala/runtime/BooleanRef") + val srByteRef = ClassBType("scala/runtime/ByteRef") + val srCharRef = ClassBType("scala/runtime/CharRef") + val srIntRef = ClassBType("scala/runtime/IntRef") + val srLongRef = ClassBType("scala/runtime/LongRef") + val srFloatRef = ClassBType("scala/runtime/FloatRef") + val srDoubleRef = ClassBType("scala/runtime/DoubleRef") + + /** + * Map from type kinds to the Java reference types. + * Useful when pushing class literals onto the operand stack (ldc instruction taking a class + * literal). + * @see Predef.classOf + * @see genConstant() + * + * TODO @lry rename to "boxedClassOfPrimitive" or so, check usages */ - val classLiteral = immutable.Map[BType, BType]( + val classLiteral = immutable.Map[BType, ClassBType]( UNIT -> BOXED_UNIT, BOOL -> BOXED_BOOLEAN, BYTE -> BOXED_BYTE, @@ -710,7 +383,7 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { DOUBLE -> BOXED_DOUBLE ) - case class MethodNameAndType(mname: String, mdesc: String) + case class MethodNameAndType(name: String, descriptor: String) val asmBoxTo: immutable.Map[BType, MethodNameAndType] = { Map( @@ -738,4 +411,3 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { ) } } - diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala index 3ef85728da0a..313d0a6e617d 100644 --- a/src/compiler/scala/tools/nsc/transform/Mixin.scala +++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala @@ -391,7 +391,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { else { sourceModule setPos sym.pos if (sourceModule.flags != MODULE) { - log("!!! Directly setting sourceModule flags for $sourceModule from %s to MODULE".format(sourceModule.flagString)) + log(s"!!! Directly setting sourceModule flags for $sourceModule from ${sourceModule.flagString} to MODULE") sourceModule.flags = MODULE } } From 4b800a12fa66542a497f189454de16a0a1866e03 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 22 May 2014 11:44:58 +0200 Subject: [PATCH 309/826] Unit tests for new BType classes --- .../scala/tools/nsc/backend/jvm/BTypes.scala | 5 +- .../tools/nsc/backend/jvm/BTypesTest.scala | 104 ++++++++++++++++++ .../scala/tools/testing/AssertUtil.scala | 17 ++- 3 files changed, 119 insertions(+), 7 deletions(-) create mode 100644 test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala index e6b2136be2bb..9aedc7f8b47b 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala @@ -256,7 +256,10 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { * * @param s A class name of the form "java/lang/String", without the surrounding 'L' and ';'. */ - def this(s: String) = this(createNewName(s)) + def this(s: String) = this({ + assert(!(s.head == 'L' && s.last == ';'), s"Descriptor instead of internal name: $s") + createNewName(s) + }) /** * The internal name of a class is the string returned by java.lang.Class.getName, with all '.' diff --git a/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala b/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala new file mode 100644 index 000000000000..b592d065012b --- /dev/null +++ b/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala @@ -0,0 +1,104 @@ +package scala.tools.nsc +package backend.jvm + +import scala.tools.testing.AssertUtil._ +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 +import org.junit.Test +import scala.tools.asm.Opcodes +import org.junit.Assert._ + +@RunWith(classOf[JUnit4]) +class BTypesTest { + val g: Global = new Global(new Settings()) + + val btypes = new BTypes[g.type](g) { + def chrs = g.chrs + override type BTypeName = g.TypeName + override def createNewName(s: String) = g.newTypeName(s) + } + + import btypes._ + + val jls = "java/lang/String" + val jlo = "java/lang/Object" + + val o = ClassBType(jlo) + val s = ClassBType(jls) + val oArr = ArrayBType(o) + val method = MethodBType(List(oArr, INT, DOUBLE, s), UNIT) + + @Test + def classBTypesEquality() { + val s1 = ClassBType(jls) + val s2 = ClassBType(jls) + val o = ClassBType(jlo) + assertEquals(s1, s2) + assertEquals(s1.hashCode, s2.hashCode) + assert(s1 != o) + assert(s2 != o) + } + + @Test + def classBTypeRequiresInternalName() { + assertThrows[AssertionError](ClassBType(s"L$jls;"), _ contains "Descriptor instead of internal name") + } + + @Test + def typedOpcodes() { + assert(UNIT.typedOpcode(Opcodes.IALOAD) == Opcodes.IALOAD) + assert(INT.typedOpcode(Opcodes.IALOAD) == Opcodes.IALOAD) + assert(BOOL.typedOpcode(Opcodes.IALOAD) == Opcodes.BALOAD) + assert(BYTE.typedOpcode(Opcodes.IALOAD) == Opcodes.BALOAD) + assert(CHAR.typedOpcode(Opcodes.IALOAD) == Opcodes.CALOAD) + assert(SHORT.typedOpcode(Opcodes.IALOAD) == Opcodes.SALOAD) + assert(FLOAT.typedOpcode(Opcodes.IALOAD) == Opcodes.FALOAD) + assert(LONG.typedOpcode(Opcodes.IALOAD) == Opcodes.LALOAD) + assert(DOUBLE.typedOpcode(Opcodes.IALOAD) == Opcodes.DALOAD) + assert(ClassBType(jls).typedOpcode(Opcodes.IALOAD) == Opcodes.AALOAD) + + assert(UNIT.typedOpcode(Opcodes.IRETURN) == Opcodes.RETURN) + assert(BOOL.typedOpcode(Opcodes.IRETURN) == Opcodes.IRETURN) + assert(CHAR.typedOpcode(Opcodes.IRETURN) == Opcodes.IRETURN) + assert(BYTE.typedOpcode(Opcodes.IRETURN) == Opcodes.IRETURN) + assert(SHORT.typedOpcode(Opcodes.IRETURN) == Opcodes.IRETURN) + assert(INT.typedOpcode(Opcodes.IRETURN) == Opcodes.IRETURN) + assert(FLOAT.typedOpcode(Opcodes.IRETURN) == Opcodes.FRETURN) + assert(LONG.typedOpcode(Opcodes.IRETURN) == Opcodes.LRETURN) + assert(DOUBLE.typedOpcode(Opcodes.IRETURN) == Opcodes.DRETURN) + assert(ClassBType(jls).typedOpcode(Opcodes.IRETURN) == Opcodes.ARETURN) + } + + @Test + def descriptors() { + assert(o.descriptor == "Ljava/lang/Object;") + assert(s.descriptor == "Ljava/lang/String;") + assert(oArr.descriptor == "[Ljava/lang/Object;") + assert(method.descriptor == "([Ljava/lang/Object;IDLjava/lang/String;)V") + } + + @Test + def toAsmTypeTest() { + for (t <- List(o, s, oArr, method, INT, UNIT, DOUBLE)) { + assertEquals(o.descriptor, o.toASMType.getDescriptor) + } + } + + @Test + def parseMethodDescriptorTest() { + val descriptors = List( + "()V", + "(ID)I", + "([[I[D)[D", + s"(L$jls;[L$jlo;)[[L$jls;", + s"(IL$jlo;)L$jls;" + ) + for (d <- descriptors) { + assertEquals(d, MethodBType(d).descriptor) + } + + // class types in method descriptor need surrounding 'L' and ';' + assertThrows[MatchError](MethodBType("(java/lang/String)V"), _ == "j (of class java.lang.Character)") + assertThrows[AssertionError](MethodBType("I"), _ contains "Not a valid method descriptor") + } +} diff --git a/test/junit/scala/tools/testing/AssertUtil.scala b/test/junit/scala/tools/testing/AssertUtil.scala index 9efac64a9791..9a97c5114fca 100644 --- a/test/junit/scala/tools/testing/AssertUtil.scala +++ b/test/junit/scala/tools/testing/AssertUtil.scala @@ -5,15 +5,20 @@ package testing * that are ultimately based on junit.Assert primitives. */ object AssertUtil { - /** Check if exception T (or a subclass) was thrown during evaluation of f. - * If any other exception or throwable is found instead it will be re-thrown. + /** + * Check if throwable T (or a subclass) was thrown during evaluation of f, and that its message + * satisfies the `checkMessage` predicate. + * If any other exception will be re-thrown. */ - def assertThrows[T <: Exception](f: => Any)(implicit manifest: Manifest[T]): Unit = + def assertThrows[T <: Throwable](f: => Any, + checkMessage: String => Boolean = s => true) + (implicit manifest: Manifest[T]): Unit = { try f catch { - case e: Exception => - val clazz = manifest.erasure.asInstanceOf[Class[T]] + case e: Throwable if checkMessage(e.getMessage) => + val clazz = manifest.runtimeClass if (!clazz.isAssignableFrom(e.getClass)) throw e } -} \ No newline at end of file + } +} From ec3bcc2d6d7b953ad16675b81d8b5d401cb44e67 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 22 May 2014 14:29:53 +0200 Subject: [PATCH 310/826] Unit tests for reflect/internal/Names --- .../scala/reflect/internal/NamesTest.scala | 95 +++++++++++++++++++ 1 file changed, 95 insertions(+) create mode 100644 test/junit/scala/reflect/internal/NamesTest.scala diff --git a/test/junit/scala/reflect/internal/NamesTest.scala b/test/junit/scala/reflect/internal/NamesTest.scala new file mode 100644 index 000000000000..549c10abedbc --- /dev/null +++ b/test/junit/scala/reflect/internal/NamesTest.scala @@ -0,0 +1,95 @@ +package scala.reflect.internal + +import scala.tools.testing.AssertUtil._ +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 +import org.junit.Test +import org.junit.Assert._ +import scala.tools.nsc.symtab.SymbolTableForUnitTesting + +@RunWith(classOf[JUnit4]) +class NamesTest { + object symbolTable extends SymbolTableForUnitTesting + import symbolTable._ + + val h1 = newTermName("hai") + val h2 = newTermName("hai") + val f = newTermName("fisch") + + val h1y = h1.toTypeName + val h2y = newTypeName("hai") + val fy = newTypeName("fisch") + + val uy = newTypeName("uhu") + val u = uy.toTermName // calling toTermName after constructing a typeName. This tests the fact + // that creating a typeName always also first creates a termName. There is + // an assertion for that in toTermName. + + @Test + def termNamesAreHashConsed() { + assertTrue(h1 eq h2) + assertEquals(h1, h2) + assertTrue(h1 ne f) + assertTrue(h1 != f) + } + + @Test + def termNamesNotEqualsTypeNames() { + assert(h1 ne h1y) + assert(h1 != h1y) + assert(h2 ne h2y) + assert(h2 != h2y) + } + + @Test + def termNamesTypeNamesSameRange() { + assert(h1.start == h1y.start && h1.length == h1y.length) + assert(h2.start == h2y.start && h2.length == h2y.length) + assert(u.start == uy.start && u.length == uy.length) + } + + @Test + def testLookupTypeName() { + assert(lookupTypeName("hai".toCharArray) eq h1y) + assert(lookupTypeName("fisch".toCharArray) eq fy) + assert(lookupTypeName("uhu".toCharArray) eq uy) + + assertThrows[AssertionError](lookupTypeName("dog".toCharArray), _ contains "not yet created") + val d = newTermName("dog") + assertThrows[AssertionError](lookupTypeName("dog".toCharArray), _ contains "not yet created") + val dy = d.toTypeName + assert(lookupTypeName("dog".toCharArray) eq dy) + } + + @Test + def emptyName() { + val z = newTermName("") + val zy = z.toTypeName + assertEquals(z.toString, "") + assertEquals(zy.toString, "") + assert(z eq newTermName("")) + assert(zy eq newTypeName("")) + } + + @Test + def subNameTest() { + val i = f.subName(1, f.length) + assert(i.start == (f.start + 1) && i.length == (f.length - 1)) + assert(f.subName(0, f.length) eq f) + + val iy = fy.subName(1, fy.length) + assert(iy.start == (fy.start + 1) && iy.length == (fy.length - 1)) + assert(fy.subName(0, fy.length) eq fy) + + assert(f.subName(1,1) eq newTermName("")) + assert(f.subName(1, 0) eq newTermName("")) + + assertThrows[IllegalArgumentException](f.subName(0 - f.start - 1, 1)) + } + + @Test + def stringEqualsTest() { + assert(h1 string_== h2) + assert(h1 string_== h1y) + } +} From 17b99e2587251cdb02e9d96fc2f87143be3160b8 Mon Sep 17 00:00:00 2001 From: harryhuk Date: Tue, 3 Jun 2014 11:46:55 +0100 Subject: [PATCH 311/826] Update AnyVals.scala Corrected api doc for >> operator to say it bit-shifts right rather than left, and fills the left bits rather than the right bit --- src/compiler/scala/tools/cmd/gen/AnyVals.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/scala/tools/cmd/gen/AnyVals.scala b/src/compiler/scala/tools/cmd/gen/AnyVals.scala index 842851b4f60d..e78589908ca2 100644 --- a/src/compiler/scala/tools/cmd/gen/AnyVals.scala +++ b/src/compiler/scala/tools/cmd/gen/AnyVals.scala @@ -111,8 +111,8 @@ import scala.language.implicitConversions""" " */"), Op(">>", "/**\n" + - " * Returns this value bit-shifted left by the specified number of bits,\n" + - " * filling in the right bits with the same value as the left-most bit of this.\n" + + " * Returns this value bit-shifted right by the specified number of bits,\n" + + " * filling in the left bits with the same value as the left-most bit of this.\n" + " * The effect of this is to retain the sign of the value.\n" + " * @example {{{\n" + " * -21 >> 3 == -3\n" + From 0d5fa2ab0e33bc2f27cf6e7b4943121aa08f1cb0 Mon Sep 17 00:00:00 2001 From: Todd Vierling Date: Fri, 23 May 2014 11:17:49 -0400 Subject: [PATCH 312/826] Add documentation to parts of scala.concurrent. --- src/library/scala/concurrent/Channel.scala | 17 +++++++++++++---- .../scala/concurrent/ExecutionContext.scala | 4 ++-- src/library/scala/concurrent/SyncVar.scala | 16 +++++++++++++--- src/library/scala/concurrent/package.scala | 5 +++++ 4 files changed, 33 insertions(+), 9 deletions(-) diff --git a/src/library/scala/concurrent/Channel.scala b/src/library/scala/concurrent/Channel.scala index 067244bd1ce4..89ad7d8c0e93 100644 --- a/src/library/scala/concurrent/Channel.scala +++ b/src/library/scala/concurrent/Channel.scala @@ -10,8 +10,10 @@ package scala.concurrent -/** This class ... +/** This class provides a simple FIFO queue of data objects, + * which are read by one or more reader threads. * + * @tparam A type of data exchanged * @author Martin Odersky * @version 1.0, 10/03/2003 */ @@ -20,11 +22,14 @@ class Channel[A] { var elem: A = _ var next: LinkedList[A] = null } - private var written = new LinkedList[A] // FIFO buffer, realized through + private var written = new LinkedList[A] // FIFO queue, realized through private var lastWritten = written // aliasing of a linked list private var nreaders = 0 - /** + /** Append a value to the FIFO queue to be read by `read`. + * This operation is nonblocking and can be executed by any thread. + * + * @param x object to enqueue to this channel */ def write(x: A) = synchronized { lastWritten.elem = x @@ -33,6 +38,11 @@ class Channel[A] { if (nreaders > 0) notify() } + /** Retrieve the next waiting object from the FIFO queue, + * blocking if necessary until an object is available. + * + * @return next object dequeued from this channel + */ def read: A = synchronized { while (written.next == null) { try { @@ -45,5 +55,4 @@ class Channel[A] { written = written.next x } - } diff --git a/src/library/scala/concurrent/ExecutionContext.scala b/src/library/scala/concurrent/ExecutionContext.scala index a1e94c88766e..4674c9174b88 100644 --- a/src/library/scala/concurrent/ExecutionContext.scala +++ b/src/library/scala/concurrent/ExecutionContext.scala @@ -77,12 +77,12 @@ trait ExecutionContext { } /** - * Union interface since Java does not support union types + * An [[ExecutionContext]] that is also a Java [[Executor]]. */ trait ExecutionContextExecutor extends ExecutionContext with Executor /** - * Union interface since Java does not support union types + * An [[ExecutionContext]] that is also a Java [[ExecutorService]]. */ trait ExecutionContextExecutorService extends ExecutionContextExecutor with ExecutorService diff --git a/src/library/scala/concurrent/SyncVar.scala b/src/library/scala/concurrent/SyncVar.scala index d5dc3d7e3fdf..494c9558337b 100644 --- a/src/library/scala/concurrent/SyncVar.scala +++ b/src/library/scala/concurrent/SyncVar.scala @@ -13,6 +13,7 @@ import java.util.concurrent.TimeUnit /** A class to provide safe concurrent access to a mutable cell. * All methods are synchronized. * + * @tparam A type of the contained value * @author Martin Odersky * @version 1.0, 10/03/2003 */ @@ -20,6 +21,12 @@ class SyncVar[A] { private var isDefined: Boolean = false private var value: Option[A] = None + /** + * Waits for this SyncVar to become defined and returns + * the result, without modifying the stored value. + * + * @return value that is held in this container + */ def get: A = synchronized { while (!isDefined) wait() value.get @@ -57,8 +64,12 @@ class SyncVar[A] { value } - /** Waits for this SyncVar to become defined and returns - * the result */ + /** + * Waits for this SyncVar to become defined and returns + * the result, unsetting the stored value before returning. + * + * @return value that was held in this container + */ def take(): A = synchronized { try get finally unsetVal() @@ -129,4 +140,3 @@ class SyncVar[A] { } } - diff --git a/src/library/scala/concurrent/package.scala b/src/library/scala/concurrent/package.scala index cc1350f5a957..4d88253de451 100644 --- a/src/library/scala/concurrent/package.scala +++ b/src/library/scala/concurrent/package.scala @@ -55,6 +55,11 @@ package object concurrent { } package concurrent { + /** + * This marker trait is used by [[Await]] to ensure that [[Awaitable.ready]] and [[Awaitable.result]] + * are not directly called by user code. An implicit instance of this trait is only available when + * user code is currently calling the methods on [[Await]]. + */ @implicitNotFound("Don't call `Awaitable` methods directly, use the `Await` object.") sealed trait CanAwait From 56f9140d4e3c8f697251897f30e2af677ddebf69 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Wed, 4 Jun 2014 08:37:28 +0200 Subject: [PATCH 313/826] Fix emitting Array(1).clone() in GenBCode --- .../scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala | 7 ++++++- src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala | 3 ++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index 1285ca68629d..bffa4bc51daf 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -686,7 +686,12 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { case _ => } if ((targetTypeKind != null) && (sym == definitions.Array_clone) && invokeStyle.isDynamic) { - val target: String = targetTypeKind.asClassBType.internalName + // An invokevirtual points to a CONSTANT_Methodref_info which in turn points to a + // CONSTANT_Class_info of the receiver type. + // The JVMS is not explicit about this, but that receiver type may be an array type + // descriptor (instead of a class internal name): + // invokevirtual #2; //Method "[I".clone:()Ljava/lang/Object + val target: String = targetTypeKind.asRefBType.classOrArrayType bc.invokevirtual(target, "clone", "()Ljava/lang/Object;") } else { diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala index 9aedc7f8b47b..5b0fa6f7a8f8 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala @@ -217,7 +217,8 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { sealed trait RefBType extends BType { /** * The class or array type of this reference type. Used for ANEWARRAY, MULTIANEWARRAY, - * INSTANCEOF and CHECKCAST instructions. + * INSTANCEOF and CHECKCAST instructions. Also used for emitting invokevirtual calls to + * (a: Array[T]).clone() for any T, see genApply. * * In contrast to the descriptor, this string does not contain the surrounding 'L' and ';' for * class types, for example "java/lang/String". From 85a26409f23ed8df6e82e763cb4415d519c3e9f5 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Wed, 26 Feb 2014 00:31:47 +0100 Subject: [PATCH 314/826] SI-7372 fix wrong insertion point for binary & linear search. It should return the position the value would have if it was a part of the sequence. Somehow even the test was wrong. --- src/library/scala/collection/Searching.scala | 4 ++-- test/files/run/search.check | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/library/scala/collection/Searching.scala b/src/library/scala/collection/Searching.scala index fec4bbf5025a..6a56410d4c54 100644 --- a/src/library/scala/collection/Searching.scala +++ b/src/library/scala/collection/Searching.scala @@ -88,7 +88,7 @@ object Searching { @tailrec private def binarySearch[B >: A](elem: B, from: Int, to: Int) (implicit ord: Ordering[B]): SearchResult = { - if ((to-from) == 1) InsertionPoint(from) else { + if ((to-from) == 1) InsertionPoint(from + 1) else { val idx = from+(to-from)/2 math.signum(ord.compare(elem, coll(idx))) match { case -1 => binarySearch(elem, from, idx)(ord) @@ -105,7 +105,7 @@ object Searching { while (it.hasNext) { val cur = it.next() if (ord.equiv(elem, cur)) return Found(idx) - else if (ord.lt(elem, cur)) return InsertionPoint(idx-1) + else if (ord.lt(elem, cur)) return InsertionPoint(idx) idx += 1 } InsertionPoint(idx) diff --git a/test/files/run/search.check b/test/files/run/search.check index a8856965092a..e0c55043e3ec 100644 --- a/test/files/run/search.check +++ b/test/files/run/search.check @@ -1,6 +1,6 @@ Found(2) Found(4) -InsertionPoint(9) +InsertionPoint(10) Found(2) Found(4) -InsertionPoint(9) +InsertionPoint(10) From 86fc1ceae4db611aa4f990973cea484c41f79e44 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Wed, 4 Jun 2014 12:50:34 +0200 Subject: [PATCH 315/826] Disable OSGi tests under Java 8 I've lodged SI-8642 with more details of the failure to make sure we get them going again. --- build.xml | 32 ++++++++++++++++++-------------- 1 file changed, 18 insertions(+), 14 deletions(-) diff --git a/build.xml b/build.xml index ed12eb06d200..c407c8d797f4 100755 --- a/build.xml +++ b/build.xml @@ -1357,20 +1357,24 @@ TODO: - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + From eec8ba0b01ca2d7fd74faba8b1f4e187691bb3ca Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Wed, 4 Jun 2014 14:55:23 +0200 Subject: [PATCH 316/826] Java 6-8 agnosticism for a test Under Java 8, the output contains newly added methods in j.u.Iterator. I've created cut down, test-local versions of the relevant types to decouple. --- test/files/presentation/ide-bug-1000531.check | 111 ++---------------- .../ide-bug-1000531/src/CrashOnLoad.scala | 15 ++- .../ide-bug-1000531/src/TestIterable.java | 7 ++ 3 files changed, 30 insertions(+), 103 deletions(-) create mode 100644 test/files/presentation/ide-bug-1000531/src/TestIterable.java diff --git a/test/files/presentation/ide-bug-1000531.check b/test/files/presentation/ide-bug-1000531.check index d8c7a369f70e..12eafcd6de1d 100644 --- a/test/files/presentation/ide-bug-1000531.check +++ b/test/files/presentation/ide-bug-1000531.check @@ -1,111 +1,24 @@ -reload: CrashOnLoad.scala +reload: CrashOnLoad.scala, TestIterable.java -askTypeCompletion at CrashOnLoad.scala(6,12) +askTypeCompletion at CrashOnLoad.scala(6,11) ================================================================================ -[response] askTypeCompletion at (6,12) -retrieved 117 members +[response] askTypeCompletion at (6,11) +retrieved 30 members [inaccessible] protected[package lang] def clone(): Object [inaccessible] protected[package lang] def finalize(): Unit -[inaccessible] protected[this] def reversed: List[B] -class GroupedIterator[B >: A] extends AbstractIterator[Seq[B]] with Iterator[Seq[B]] def +(other: String): String -def ++[B >: B](that: => scala.collection.GenTraversableOnce[B]): Iterator[B] -def ->[B](y: B): (java.util.Iterator[B], B) -def /:[B](z: B)(op: (B, B) => B): B -def :\[B](z: B)(op: (B, B) => B): B -def addString(b: StringBuilder): StringBuilder -def addString(b: StringBuilder,sep: String): StringBuilder -def addString(b: StringBuilder,start: String,sep: String,end: String): StringBuilder -def aggregate[B](z: => B)(seqop: (B, B) => B,combop: (B, B) => B): B -def buffered: scala.collection.BufferedIterator[B] -def collectFirst[B](pf: PartialFunction[B,B]): Option[B] -def collect[B](pf: PartialFunction[B,B]): Iterator[B] -def contains(elem: Any): Boolean -def copyToArray[B >: B](xs: Array[B]): Unit -def copyToArray[B >: B](xs: Array[B],start: Int): Unit -def copyToArray[B >: B](xs: Array[B],start: Int,len: Int): Unit -def copyToBuffer[B >: B](dest: scala.collection.mutable.Buffer[B]): Unit -def corresponds[B](that: scala.collection.GenTraversableOnce[B])(p: (B, B) => Boolean): Boolean -def count(p: B => Boolean): Int -def drop(n: Int): Iterator[B] -def dropWhile(p: B => Boolean): Iterator[B] -def duplicate: (Iterator[B], Iterator[B]) -def ensuring(cond: Boolean): java.util.Iterator[B] -def ensuring(cond: Boolean,msg: => Any): java.util.Iterator[B] -def ensuring(cond: java.util.Iterator[B] => Boolean): java.util.Iterator[B] -def ensuring(cond: java.util.Iterator[B] => Boolean,msg: => Any): java.util.Iterator[B] +def ->[B](y: B): (other.TestIterator[Nothing], B) +def ensuring(cond: Boolean): other.TestIterator[Nothing] +def ensuring(cond: Boolean,msg: => Any): other.TestIterator[Nothing] +def ensuring(cond: other.TestIterator[Nothing] => Boolean): other.TestIterator[Nothing] +def ensuring(cond: other.TestIterator[Nothing] => Boolean,msg: => Any): other.TestIterator[Nothing] def equals(x$1: Any): Boolean -def exists(p: B => Boolean): Boolean -def filter(p: B => Boolean): Iterator[B] -def filterNot(p: B => Boolean): Iterator[B] -def find(p: B => Boolean): Option[B] -def flatMap[B](f: B => scala.collection.GenTraversableOnce[B]): Iterator[B] -def foldLeft[B](z: B)(op: (B, B) => B): B -def foldRight[B](z: B)(op: (B, B) => B): B -def fold[A1 >: B](z: A1)(op: (A1, A1) => A1): A1 -def forall(p: B => Boolean): Boolean -def foreach[U](f: B => U): Unit def formatted(fmtstr: String): String -def grouped[B >: B](size: Int): Iterator[B]#GroupedIterator[B] -def hasDefiniteSize: Boolean -def hasNext(): Boolean +def hasNext: Boolean def hashCode(): Int -def indexOf[B >: B](elem: B): Int -def indexWhere(p: B => Boolean): Int -def isEmpty: Boolean -def isTraversableAgain: Boolean -def length: Int -def map[B](f: B => B): Iterator[B] -def maxBy[B](f: B => B)(implicit cmp: Ordering[B]): B -def max[B >: B](implicit cmp: Ordering[B]): B -def minBy[B](f: B => B)(implicit cmp: Ordering[B]): B -def min[B >: B](implicit cmp: Ordering[B]): B -def mkString(sep: String): String -def mkString(start: String,sep: String,end: String): String -def mkString: String -def next(): B -def nonEmpty: Boolean -def padTo[A1 >: B](len: Int,elem: A1): Iterator[A1] -def partition(p: B => Boolean): (Iterator[B], Iterator[B]) -def patch[B >: B](from: Int,patchElems: Iterator[B],replaced: Int): Iterator[B] -def product[B >: B](implicit num: Numeric[B]): B -def reduceLeftOption[B >: B](op: (B, B) => B): Option[B] -def reduceLeft[B >: B](op: (B, B) => B): B -def reduceOption[A1 >: B](op: (A1, A1) => A1): Option[A1] -def reduceRightOption[B >: B](op: (B, B) => B): Option[B] -def reduceRight[B >: B](op: (B, B) => B): B -def reduce[A1 >: B](op: (A1, A1) => A1): A1 -def remove(): Unit -def sameElements(that: Iterator[_]): Boolean -def scanLeft[B](z: B)(op: (B, B) => B): Iterator[B] -def scanRight[B](z: B)(op: (B, B) => B): Iterator[B] -def seq: Iterator[B] -def size: Int -def slice(from: Int,until: Int): Iterator[B] -def sliding[B >: B](size: Int,step: Int): Iterator[B]#GroupedIterator[B] -def span(p: B => Boolean): (Iterator[B], Iterator[B]) -def sum[B >: B](implicit num: Numeric[B]): B -def take(n: Int): Iterator[B] -def takeWhile(p: B => Boolean): Iterator[B] -def toArray[B >: B](implicit evidence$1: scala.reflect.ClassTag[B]): Array[B] -def toBuffer[B >: B]: scala.collection.mutable.Buffer[B] -def toIndexedSeq: scala.collection.immutable.IndexedSeq[B] -def toIterable: Iterable[B] -def toIterator: Iterator[B] -def toList: List[B] -def toMap[T, U](implicit ev: <:<[B,(T, U)]): scala.collection.immutable.Map[T,U] -def toSeq: Seq[B] -def toSet[B >: B]: scala.collection.immutable.Set[B] -def toStream: scala.collection.immutable.Stream[B] +def next: T def toString(): String -def toTraversable: Traversable[B] -def toVector: Vector[B] -def to[Col[_]](implicit cbf: scala.collection.generic.CanBuildFrom[Nothing,B,Col[B]]): Col[B] -def withFilter(p: B => Boolean): Iterator[B] -def zipAll[B, A1 >: B, B1 >: B](that: Iterator[B],thisElem: A1,thatElem: B1): Iterator[(A1, B1)] -def zipWithIndex: Iterator[(B, Int)] -def zip[B](that: Iterator[B]): Iterator[(B, B)] -def →[B](y: B): (java.util.Iterator[B], B) +def →[B](y: B): (other.TestIterator[Nothing], B) final def !=(x$1: Any): Boolean final def ##(): Int final def ==(x$1: Any): Boolean diff --git a/test/files/presentation/ide-bug-1000531/src/CrashOnLoad.scala b/test/files/presentation/ide-bug-1000531/src/CrashOnLoad.scala index 878bbfa19e25..3f59282083f5 100644 --- a/test/files/presentation/ide-bug-1000531/src/CrashOnLoad.scala +++ b/test/files/presentation/ide-bug-1000531/src/CrashOnLoad.scala @@ -1,7 +1,14 @@ /** When this files is opened within the IDE, a typing error is reported. */ -class A[B] extends java.lang.Iterable[B] { +class A[B] extends TestIterable[B] { import scala.collection.JavaConversions._ - def iterator = Iterator.empty + def iterator: other.TestIterator[Nothing] = ??? - iterator. /*!*/ -} \ No newline at end of file + iterator./*!*/ +} + +object other { + trait TestIterator[T] { + def hasNext: Boolean + def next: T + } +} diff --git a/test/files/presentation/ide-bug-1000531/src/TestIterable.java b/test/files/presentation/ide-bug-1000531/src/TestIterable.java new file mode 100644 index 000000000000..84a6fe77f16d --- /dev/null +++ b/test/files/presentation/ide-bug-1000531/src/TestIterable.java @@ -0,0 +1,7 @@ +public abstract class TestIterable { + public abstract TestIterator iterator(); + public static abstract class TestIterator { + public abstract T next(); + public abstract boolean hasNext(); + } +} From ca3fb2506307c452bce236e431c024ed741b4ef7 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Wed, 4 Jun 2014 15:04:02 +0200 Subject: [PATCH 317/826] Support Java 8 in the checkfile for neg/t6289 --- test/files/neg/t6289.check | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/files/neg/t6289.check b/test/files/neg/t6289.check index f6f43cabd36e..989932750f2f 100644 --- a/test/files/neg/t6289.check +++ b/test/files/neg/t6289.check @@ -3,7 +3,7 @@ t6289/J.java:2: method does not override or implement a method from a supertype @Override public void foo() { } ^ 1 error -#partest java7 +#partest !java6 t6289/J.java:2: error: method does not override or implement a method from a supertype @Override public void foo() { } ^ From 62648206f04da064f3f490c412abeca195255bf7 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Wed, 4 Jun 2014 19:01:49 +0200 Subject: [PATCH 318/826] Don't crash on dead code in ICodeReader --- .../nsc/symtab/classfile/ICodeReader.scala | 48 +++++++++++-------- 1 file changed, 28 insertions(+), 20 deletions(-) diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala index 6ca2205881d7..149b4fe4469c 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/ICodeReader.scala @@ -780,32 +780,40 @@ abstract class ICodeReader extends ClassfileParser { bb = otherBlock // Console.println("\t> entering bb: " + bb) } - instr match { - case LJUMP(target) => - otherBlock = blocks(target) - bb.emitOnly(JUMP(otherBlock)) - case LCJUMP(success, failure, cond, kind) => - otherBlock = blocks(success) - val failBlock = blocks(failure) - bb.emitOnly(CJUMP(otherBlock, failBlock, cond, kind)) + if (bb.closed) { + // the basic block is closed, i.e. the previous instruction was a jump, return or throw, + // but the next instruction is not a jump target. this means that the next instruction is + // dead code. we can therefore advance until the next jump target. + debuglog(s"ICode reader skipping dead instruction $instr in classfile $instanceCode") + } else { + instr match { + case LJUMP(target) => + otherBlock = blocks(target) + bb.emitOnly(JUMP(otherBlock)) + + case LCJUMP(success, failure, cond, kind) => + otherBlock = blocks(success) + val failBlock = blocks(failure) + bb.emitOnly(CJUMP(otherBlock, failBlock, cond, kind)) - case LCZJUMP(success, failure, cond, kind) => - otherBlock = blocks(success) - val failBlock = blocks(failure) - bb.emitOnly(CZJUMP(otherBlock, failBlock, cond, kind)) + case LCZJUMP(success, failure, cond, kind) => + otherBlock = blocks(success) + val failBlock = blocks(failure) + bb.emitOnly(CZJUMP(otherBlock, failBlock, cond, kind)) - case LSWITCH(tags, targets) => - bb.emitOnly(SWITCH(tags, targets map blocks)) + case LSWITCH(tags, targets) => + bb.emitOnly(SWITCH(tags, targets map blocks)) - case RETURN(_) => - bb emitOnly instr + case RETURN(_) => + bb emitOnly instr - case THROW(clasz) => - bb emitOnly instr + case THROW(clasz) => + bb emitOnly instr - case _ => - bb emit instr + case _ => + bb emit instr + } } } From c4ec53ea504bc08af15a0ac60d14b00b734b4926 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Wed, 4 Jun 2014 21:59:15 +0200 Subject: [PATCH 319/826] Tone down the noise in the output of t7974 This makes it pass under -Ybackend:GenBCode --- test/files/run/t7974.check | 29 ----------------------------- test/files/run/t7974/Test.scala | 2 +- 2 files changed, 1 insertion(+), 30 deletions(-) diff --git a/test/files/run/t7974.check b/test/files/run/t7974.check index 0be496d8d08b..d8152d3286ee 100644 --- a/test/files/run/t7974.check +++ b/test/files/run/t7974.check @@ -1,6 +1,5 @@ public class Symbols { - // compiled from: Symbols.scala @@ -18,20 +17,14 @@ public class Symbols { // access flags 0x9 public static ()V - L0 - LINENUMBER 2 L0 GETSTATIC scala/Symbol$.MODULE$ : Lscala/Symbol$; LDC "Symbolic1" INVOKEVIRTUAL scala/Symbol$.apply (Ljava/lang/String;)Lscala/Symbol; PUTSTATIC Symbols.symbol$1 : Lscala/Symbol; - L1 - LINENUMBER 3 L1 GETSTATIC scala/Symbol$.MODULE$ : Lscala/Symbol$; LDC "Symbolic2" INVOKEVIRTUAL scala/Symbol$.apply (Ljava/lang/String;)Lscala/Symbol; PUTSTATIC Symbols.symbol$2 : Lscala/Symbol; - L2 - LINENUMBER 5 L2 GETSTATIC scala/Symbol$.MODULE$ : Lscala/Symbol$; LDC "Symbolic3" INVOKEVIRTUAL scala/Symbol$.apply (Ljava/lang/String;)Lscala/Symbol; @@ -42,63 +35,41 @@ public class Symbols { // access flags 0x1 public someSymbol1()Lscala/Symbol; - L0 - LINENUMBER 2 L0 GETSTATIC Symbols.symbol$1 : Lscala/Symbol; ARETURN - L1 - LOCALVARIABLE this LSymbols; L0 L1 0 MAXSTACK = 1 MAXLOCALS = 1 // access flags 0x1 public someSymbol2()Lscala/Symbol; - L0 - LINENUMBER 3 L0 GETSTATIC Symbols.symbol$2 : Lscala/Symbol; ARETURN - L1 - LOCALVARIABLE this LSymbols; L0 L1 0 MAXSTACK = 1 MAXLOCALS = 1 // access flags 0x1 public sameSymbol1()Lscala/Symbol; - L0 - LINENUMBER 4 L0 GETSTATIC Symbols.symbol$1 : Lscala/Symbol; ARETURN - L1 - LOCALVARIABLE this LSymbols; L0 L1 0 MAXSTACK = 1 MAXLOCALS = 1 // access flags 0x1 public someSymbol3()Lscala/Symbol; - L0 - LINENUMBER 5 L0 ALOAD 0 GETFIELD Symbols.someSymbol3 : Lscala/Symbol; ARETURN - L1 - LOCALVARIABLE this LSymbols; L0 L1 0 MAXSTACK = 1 MAXLOCALS = 1 // access flags 0x1 public ()V - L0 - LINENUMBER 6 L0 ALOAD 0 INVOKESPECIAL java/lang/Object. ()V - L1 - LINENUMBER 5 L1 ALOAD 0 GETSTATIC Symbols.symbol$3 : Lscala/Symbol; PUTFIELD Symbols.someSymbol3 : Lscala/Symbol; RETURN - L2 - LOCALVARIABLE this LSymbols; L0 L2 0 MAXSTACK = 2 MAXLOCALS = 1 } diff --git a/test/files/run/t7974/Test.scala b/test/files/run/t7974/Test.scala index 433d9061a747..29d2b9cb6453 100644 --- a/test/files/run/t7974/Test.scala +++ b/test/files/run/t7974/Test.scala @@ -6,7 +6,7 @@ import scala.tools.nsc.util.stringFromWriter object Test extends BytecodeTest { def show { - val classNode = loadClassNode("Symbols", skipDebugInfo = false) + val classNode = loadClassNode("Symbols", skipDebugInfo = true) val textifier = new Textifier classNode.accept(new TraceClassVisitor(null, textifier, null)) From ee6ffbfc5d403137b8e6a4fd91960a7cc0defd34 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Wed, 4 Jun 2014 22:17:49 +0200 Subject: [PATCH 320/826] Make test repl-javap-app independent of precise constant pool indices Allows the test to pass on both backends --- test/files/run/repl-javap-app.check | 14 ++++++++------ test/files/run/repl-javap-app.scala | 11 +++++++++++ 2 files changed, 19 insertions(+), 6 deletions(-) diff --git a/test/files/run/repl-javap-app.check b/test/files/run/repl-javap-app.check index 490860585c6a..b7e806cc0b6b 100644 --- a/test/files/run/repl-javap-app.check +++ b/test/files/run/repl-javap-app.check @@ -1,4 +1,5 @@ #partest java6 +Welcome to Scala Type in expressions to have them evaluated. Type :help for more information. @@ -6,9 +7,9 @@ scala> :javap -app MyApp$ public final void delayedEndpoint$MyApp$1(); Code: Stack=2, Locals=1, Args_size=1 - 0: getstatic #61; //Field scala/Console$.MODULE$:Lscala/Console$; - 3: ldc #63; //String Hello, delayed world. - 5: invokevirtual #67; //Method scala/Console$.println:(Ljava/lang/Object;)V + 0: getstatic #XX; //Field scala/Console$.MODULE$:Lscala/Console$; + 3: ldc #XX; //String Hello, delayed world. + 5: invokevirtual #XX; //Method scala/Console$.println:(Ljava/lang/Object;)V 8: return LocalVariableTable: Start Length Slot Name Signature @@ -16,6 +17,7 @@ public final void delayedEndpoint$MyApp$1(); scala> #partest !java6 +Welcome to Scala Type in expressions to have them evaluated. Type :help for more information. @@ -24,9 +26,9 @@ scala> :javap -app MyApp$ flags: ACC_PUBLIC, ACC_FINAL Code: stack=2, locals=1, args_size=1 - 0: getstatic #61 // Field scala/Console$.MODULE$:Lscala/Console$; - 3: ldc #63 // String Hello, delayed world. - 5: invokevirtual #67 // Method scala/Console$.println:(Ljava/lang/Object;)V + 0: getstatic #XX // Field scala/Console$.MODULE$:Lscala/Console$; + 3: ldc #XX // String Hello, delayed world. + 5: invokevirtual #XX // Method scala/Console$.println:(Ljava/lang/Object;)V 8: return LocalVariableTable: Start Length Slot Name Signature diff --git a/test/files/run/repl-javap-app.scala b/test/files/run/repl-javap-app.scala index be04920be19f..ad6076c2d590 100644 --- a/test/files/run/repl-javap-app.scala +++ b/test/files/run/repl-javap-app.scala @@ -7,4 +7,15 @@ object MyApp extends App { object Test extends ReplTest { def code = ":javap -app MyApp$" + + override def welcoming = true + + // The constant pool indices are not the same for GenASM / GenBCode, so + // replacing the exact numbers by XX. + lazy val hasConstantPoolRef = """(.*)(#\d\d)(.*)""".r + + override def normalize(s: String) = s match { + case hasConstantPoolRef(start, ref, end) => start + "#XX" + end + case _ => super.normalize(s) + } } From 5fc16e4ee7ab0be163f4a12600538ce628a6ce2a Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 5 Jun 2014 10:37:20 +0200 Subject: [PATCH 321/826] Test: classfile reading during inlining works if there is dead code --- test/files/run/icode-reader-dead-code.check | 19 +++++ test/files/run/icode-reader-dead-code.scala | 82 +++++++++++++++++++++ 2 files changed, 101 insertions(+) create mode 100644 test/files/run/icode-reader-dead-code.check create mode 100644 test/files/run/icode-reader-dead-code.scala diff --git a/test/files/run/icode-reader-dead-code.check b/test/files/run/icode-reader-dead-code.check new file mode 100644 index 000000000000..d1739fed3b18 --- /dev/null +++ b/test/files/run/icode-reader-dead-code.check @@ -0,0 +1,19 @@ +Bytecode for method f + L0 + LINENUMBER 4 L0 + ICONST_1 + IRETURN + L1 + LOCALVARIABLE this Lp/A; L0 L1 0 + MAXSTACK = 1 + MAXLOCALS = 1 +Bytecode for method f + L0 + LINENUMBER 4 L0 + ICONST_1 + ATHROW + IRETURN + L1 + LOCALVARIABLE this Lp/A; L0 L1 0 + MAXSTACK = 1 + MAXLOCALS = 1 diff --git a/test/files/run/icode-reader-dead-code.scala b/test/files/run/icode-reader-dead-code.scala new file mode 100644 index 000000000000..00ba58829f71 --- /dev/null +++ b/test/files/run/icode-reader-dead-code.scala @@ -0,0 +1,82 @@ +import java.io.{FileOutputStream, FileInputStream} + +import scala.tools.asm.{ClassWriter, Opcodes, ClassReader} +import scala.tools.asm.tree.{InsnNode, ClassNode} +import scala.tools.nsc.backend.jvm.AsmUtils +import scala.tools.partest.DirectTest +import scala.collection.JavaConverters._ + +/** + * Test that the ICodeReader does not crash if the bytecode of a method has unreachable code. + */ +object Test extends DirectTest { + def code: String = ??? + + def show(): Unit = { + // The bytecode of f will be modified using ASM by `addDeadCode` + val aCode = + """ + |package p + |class A { + | @inline final def f = 1 + |} + """.stripMargin + + val bCode = + """ + |package p + |class B { + | def g = (new A()).f + |} + """.stripMargin + + compileString(newCompiler("-usejavacp"))(aCode) + + addDeadCode() + + // If inlining fails, the compiler will issue an inliner warning that is not present in the + // check file + compileString(newCompiler("-usejavacp", "-optimise"))(bCode) + } + + def readClass(file: String) = { + val cnode = new ClassNode() + val is = new FileInputStream(file) + val reader = new ClassReader(is) + reader.accept(cnode, 0) + is.close() + cnode + } + + def writeClass(file: String, cnode: ClassNode): Unit = { + val writer = new ClassWriter(0) + cnode.accept(writer) + + val os = new FileOutputStream(file) + os.write(writer.toByteArray) + os.close() + } + + def addDeadCode() { + val file = (testOutput / "p" / "A.class").path + val cnode = readClass(file) + val method = cnode.methods.asScala.find(_.name == "f").head + + AsmUtils.traceMethod(method) + + val insns = method.instructions + val it = insns.iterator() + while (it.hasNext) { + val in = it.next() + if (in.getOpcode == Opcodes.IRETURN) { + // Insert an ATHROW before the IRETURN. The IRETURN will then be dead code. + // The ICodeReader should not crash if there's dead code. + insns.insert(in.getPrevious, new InsnNode(Opcodes.ATHROW)) + } + } + + AsmUtils.traceMethod(method) + + writeClass(file, cnode) + } +} From 3073ab4f0a8b32440f57b4c44d6c633fcc71eaac Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Thu, 5 Jun 2014 06:32:42 -0700 Subject: [PATCH 322/826] Java 8 support for run/repl-javap-app.check Just adding the java 8 output. No attempt to finesse anything. But the partest mechanism does still need auto-update of these conditional check files, plus expression evaluation of the condition. --- test/files/run/repl-javap-app.check | 25 ++++++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/test/files/run/repl-javap-app.check b/test/files/run/repl-javap-app.check index b7e806cc0b6b..1136b415d71f 100644 --- a/test/files/run/repl-javap-app.check +++ b/test/files/run/repl-javap-app.check @@ -16,7 +16,7 @@ public final void delayedEndpoint$MyApp$1(); 0 9 0 this LMyApp$; scala> -#partest !java6 +#partest java7 Welcome to Scala Type in expressions to have them evaluated. Type :help for more information. @@ -38,3 +38,26 @@ scala> :javap -app MyApp$ } scala> +#partest java8 +Welcome to Scala +Type in expressions to have them evaluated. +Type :help for more information. + +scala> :javap -app MyApp$ + public final void delayedEndpoint$MyApp$1(); + descriptor: ()V + flags: ACC_PUBLIC, ACC_FINAL + Code: + stack=2, locals=1, args_size=1 + 0: getstatic #XX // Field scala/Console$.MODULE$:Lscala/Console$; + 3: ldc #XX // String Hello, delayed world. + 5: invokevirtual #XX // Method scala/Console$.println:(Ljava/lang/Object;)V + 8: return + LocalVariableTable: + Start Length Slot Name Signature + 0 9 0 this LMyApp$; + LineNumberTable: + line 5: 0 +} + +scala> From ad9d87b1faad22c1a2e05351757c0a940e2a0ef2 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Wed, 28 May 2014 15:20:01 +0200 Subject: [PATCH 323/826] SI-8631 Treat `A with Sealed` as enumerable for pattern matching Enumerate the subtypes of sealed parent types of refinement types, and filter those that conform to the refinement type. Such types can crop up easily when LUB-bing case classes which add `Product with Serializable` to the mix. --- .../nsc/transform/patmat/MatchAnalysis.scala | 10 +++++++ .../neg/virtpatmat_exhaust_compound.check | 15 ++++++++++ .../neg/virtpatmat_exhaust_compound.flags | 1 + .../neg/virtpatmat_exhaust_compound.scala | 29 +++++++++++++++++++ 4 files changed, 55 insertions(+) create mode 100644 test/files/neg/virtpatmat_exhaust_compound.check create mode 100644 test/files/neg/virtpatmat_exhaust_compound.flags create mode 100644 test/files/neg/virtpatmat_exhaust_compound.scala diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala index 894f959319a8..3ef9b8c0b45a 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala @@ -105,6 +105,16 @@ trait TreeAndTypeAnalysis extends Debugging { case modSym: ModuleClassSymbol => Some(List(tp)) // make sure it's not a primitive, else (5: Byte) match { case 5 => ... } sees no Byte + case sym: RefinementClassSymbol => + val parentSubtypes: List[Option[List[Type]]] = tp.parents.map(parent => enumerateSubtypes(parent)) + if (parentSubtypes exists (_.isDefined)) + // If any of the parents is enumerable, then the refinement type is enumerable. + Some( + // We must only include subtypes of the parents that conform to `tp`. + // See neg/virtpatmat_exhaust_compound.scala for an example. + parentSubtypes flatMap (_.getOrElse(Nil)) filter (_ <:< tp) + ) + else None case sym if !sym.isSealed || isPrimitiveValueClass(sym) => debug.patmat("enum unsealed "+ ((tp, sym, sym.isSealed, isPrimitiveValueClass(sym)))) None diff --git a/test/files/neg/virtpatmat_exhaust_compound.check b/test/files/neg/virtpatmat_exhaust_compound.check new file mode 100644 index 000000000000..72e034068263 --- /dev/null +++ b/test/files/neg/virtpatmat_exhaust_compound.check @@ -0,0 +1,15 @@ +virtpatmat_exhaust_compound.scala:14: warning: match may not be exhaustive. +It would fail on the following inputs: O1, O2, O4 + a match { + ^ +virtpatmat_exhaust_compound.scala:18: warning: match may not be exhaustive. +It would fail on the following input: O4 + def t1(a: Product with Base with Base2) = a match { + ^ +virtpatmat_exhaust_compound.scala:22: warning: match may not be exhaustive. +It would fail on the following input: O2 + def t2(a: Product with Base { def foo: Int }) = a match { + ^ +error: No warnings can be incurred under -Xfatal-warnings. +three warnings found +one error found diff --git a/test/files/neg/virtpatmat_exhaust_compound.flags b/test/files/neg/virtpatmat_exhaust_compound.flags new file mode 100644 index 000000000000..85d8eb2ba295 --- /dev/null +++ b/test/files/neg/virtpatmat_exhaust_compound.flags @@ -0,0 +1 @@ +-Xfatal-warnings diff --git a/test/files/neg/virtpatmat_exhaust_compound.scala b/test/files/neg/virtpatmat_exhaust_compound.scala new file mode 100644 index 000000000000..386c7af98dee --- /dev/null +++ b/test/files/neg/virtpatmat_exhaust_compound.scala @@ -0,0 +1,29 @@ +sealed trait Base +case object O1 extends Base +case object O2 extends Base { + def foo: Int = 0 +} + +sealed trait Base2 +case object O3 extends Base2 + +case object O4 extends Base with Base2 + +object Test { + val a /*: Product with Serialiable with Base */ = if (true) O1 else O2 + a match { + case null => + } + + def t1(a: Product with Base with Base2) = a match { + case null => // O1..O3 should *not* be possible here + } + + def t2(a: Product with Base { def foo: Int }) = a match { + case null => // O2 in the domain + } + + def t3(a: Product with Base { def bar: Int }) = a match { + case null => // nothing in the domain + } +} From 1ed2031c3e0c342f4aa249dc16970c9e42dbe33f Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Tue, 10 Jun 2014 17:21:55 +0200 Subject: [PATCH 324/826] Refactor `enumerateSubtypes` - reorder to make "unenumerable" the last case - reunite an orphaned comment with its loved ones. --- .../tools/nsc/transform/patmat/MatchAnalysis.scala | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala index 3ef9b8c0b45a..13c7a0996a57 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala @@ -104,7 +104,6 @@ trait TreeAndTypeAnalysis extends Debugging { // TODO case _ if tp.isTupleType => // recurse into component types case modSym: ModuleClassSymbol => Some(List(tp)) - // make sure it's not a primitive, else (5: Byte) match { case 5 => ... } sees no Byte case sym: RefinementClassSymbol => val parentSubtypes: List[Option[List[Type]]] = tp.parents.map(parent => enumerateSubtypes(parent)) if (parentSubtypes exists (_.isDefined)) @@ -115,10 +114,8 @@ trait TreeAndTypeAnalysis extends Debugging { parentSubtypes flatMap (_.getOrElse(Nil)) filter (_ <:< tp) ) else None - case sym if !sym.isSealed || isPrimitiveValueClass(sym) => - debug.patmat("enum unsealed "+ ((tp, sym, sym.isSealed, isPrimitiveValueClass(sym)))) - None - case sym => + // make sure it's not a primitive, else (5: Byte) match { case 5 => ... } sees no Byte + case sym if sym.isSealed && !isPrimitiveValueClass(sym) => val subclasses = debug.patmatResult(s"enum $sym sealed, subclasses")( // symbols which are both sealed and abstract need not be covered themselves, because // all of their children must be and they cannot otherwise be created. @@ -146,6 +143,9 @@ trait TreeAndTypeAnalysis extends Debugging { else None } }) + case sym => + debug.patmat("enum unsealed "+ ((tp, sym, sym.isSealed, isPrimitiveValueClass(sym)))) + None } // approximate a type to the static type that is fully checkable at run time, From 7046d73e2a1d88273a8382f27a4fb0af6f87db3b Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Fri, 23 May 2014 12:26:43 +0200 Subject: [PATCH 325/826] SI-8611 Avoid accidental patmat unification with refinement types In the enclosed test, t8611a.scala, the patterns `O.{A, B}` were incorrect treated as equivelent by the combination of `uniqueTpForTree` and `Const.uniqueTpForTree`. `uniqueTpForTree` used `Type#narrow` to try to create a distinct type for each new pattern tree it encountered. However, narrowing a `RefinedType` does not create a distinct type as we are used to when narrowing, e.g. a class type. // Type def narrow: Type = if (phase.erasedTypes) this else { val cowner = commonOwner(this) refinedType(this :: Nil, cowner, EmptyScope, cowner.pos).narrow } // CompoundType override def narrow: Type = typeSymbol.thisType This commit creates a fresh existential type symbol rather than trying to use `narrow`. I've included a unit test to show the sublteties of narrowing refinment types. --- .../tools/nsc/transform/patmat/Logic.scala | 25 +++++---- test/files/run/t8611a.flags | 1 + test/files/run/t8611a.scala | 16 ++++++ test/files/run/t8611b.flags | 1 + test/files/run/t8611b.scala | 54 +++++++++++++++++++ test/files/run/t8611c.flags | 1 + test/files/run/t8611c.scala | 21 ++++++++ .../scala/reflect/internal/TypesTest.scala | 35 ++++++++++++ 8 files changed, 145 insertions(+), 9 deletions(-) create mode 100644 test/files/run/t8611a.flags create mode 100644 test/files/run/t8611a.scala create mode 100644 test/files/run/t8611b.flags create mode 100644 test/files/run/t8611b.scala create mode 100644 test/files/run/t8611c.flags create mode 100644 test/files/run/t8611c.scala create mode 100644 test/junit/scala/reflect/internal/TypesTest.scala diff --git a/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala b/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala index fde0aca5849e..0899507bab4d 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/Logic.scala @@ -505,7 +505,7 @@ trait ScalaLogic extends Interface with Logic with TreeAndTypeAnalysis { } - import global.{ConstantType, Constant, SingletonType, Literal, Ident, singleType} + import global.{ConstantType, Constant, EmptyScope, SingletonType, Literal, Ident, refinedType, singleType, TypeBounds, NoSymbol} import global.definitions._ @@ -538,23 +538,30 @@ trait ScalaLogic extends Interface with Logic with TreeAndTypeAnalysis { private val trees = mutable.HashSet.empty[Tree] // hashconsing trees (modulo value-equality) - private[TreesAndTypesDomain] def uniqueTpForTree(t: Tree): Type = - // a new type for every unstable symbol -- only stable value are uniqued - // technically, an unreachable value may change between cases - // thus, the failure of a case that matches on a mutable value does not exclude the next case succeeding - // (and thuuuuus, the latter case must be considered reachable) - if (!t.symbol.isStable) t.tpe.narrow + private[TreesAndTypesDomain] def uniqueTpForTree(t: Tree): Type = { + def freshExistentialSubtype(tp: Type): Type = { + // SI-8611 tp.narrow is tempting, but unsuitable. See `testRefinedTypeSI8611` for an explanation. + NoSymbol.freshExistential("").setInfo(TypeBounds.upper(tp)).tpe + } + + if (!t.symbol.isStable) { + // Create a fresh type for each unstable value, since we can never correlate it to another value. + // For example `case X => case X =>` should not complaing about the second case being unreachable, + // if X is mutable. + freshExistentialSubtype(t.tpe) + } else trees find (a => a.correspondsStructure(t)(sameValue)) match { case Some(orig) => - debug.patmat("unique tp for tree: "+ ((orig, orig.tpe))) + debug.patmat("unique tp for tree: " + ((orig, orig.tpe))) orig.tpe case _ => // duplicate, don't mutate old tree (TODO: use a map tree -> type instead?) - val treeWithNarrowedType = t.duplicate setType t.tpe.narrow + val treeWithNarrowedType = t.duplicate setType freshExistentialSubtype(t.tpe) debug.patmat("uniqued: "+ ((t, t.tpe, treeWithNarrowedType.tpe))) trees += treeWithNarrowedType treeWithNarrowedType.tpe } + } } sealed abstract class Const { diff --git a/test/files/run/t8611a.flags b/test/files/run/t8611a.flags new file mode 100644 index 000000000000..85d8eb2ba295 --- /dev/null +++ b/test/files/run/t8611a.flags @@ -0,0 +1 @@ +-Xfatal-warnings diff --git a/test/files/run/t8611a.scala b/test/files/run/t8611a.scala new file mode 100644 index 000000000000..99304df762f9 --- /dev/null +++ b/test/files/run/t8611a.scala @@ -0,0 +1,16 @@ +trait K +trait L + +object O { + type LK = K with L + val A: LK = new K with L + val B: LK = new K with L +} + +object Test extends App { + val scrut: O.LK = O.B + scrut match { + case O.A => ??? + case O.B => // spurious unreachable + } +} diff --git a/test/files/run/t8611b.flags b/test/files/run/t8611b.flags new file mode 100644 index 000000000000..85d8eb2ba295 --- /dev/null +++ b/test/files/run/t8611b.flags @@ -0,0 +1 @@ +-Xfatal-warnings diff --git a/test/files/run/t8611b.scala b/test/files/run/t8611b.scala new file mode 100644 index 000000000000..2df17c9ca001 --- /dev/null +++ b/test/files/run/t8611b.scala @@ -0,0 +1,54 @@ +sealed trait KrafsDescription + +abstract class NotWorkingEnum extends Enumeration { + + type ExtendedValue = Value with KrafsDescription + + def Enum(inDescription: String): ExtendedValue = { + new Val(nextId) with KrafsDescription { + } + } +} + +abstract class WorkingEnum extends Enumeration { + + type ExtendedValue = Value + + def Enum(inDescription: String): ExtendedValue = { + new Val(nextId) { + } + } +} + +object NotWorkingTab extends NotWorkingEnum { + val a = Enum("A") + val b = Enum("B") +} + +object WorkingTab extends WorkingEnum { + val a = Enum("A") + val b = Enum("B") +} + +object Test extends App { + testGris() + testWorking() + + def testGris() { + val pipp = NotWorkingTab.b + pipp match { + case NotWorkingTab.a => ??? + case NotWorkingTab.b => + case _ => ??? + } + } + + def testWorking() { + val stuff = WorkingTab.a + stuff match { + case WorkingTab.a => + case WorkingTab.b => ??? + case _ => ??? + } + } +} diff --git a/test/files/run/t8611c.flags b/test/files/run/t8611c.flags new file mode 100644 index 000000000000..85d8eb2ba295 --- /dev/null +++ b/test/files/run/t8611c.flags @@ -0,0 +1 @@ +-Xfatal-warnings diff --git a/test/files/run/t8611c.scala b/test/files/run/t8611c.scala new file mode 100644 index 000000000000..2bd17f29a559 --- /dev/null +++ b/test/files/run/t8611c.scala @@ -0,0 +1,21 @@ +trait K +trait L + +object O { + type LK = K with L +} + +object Test extends App { + local + + def local = { + val A: O.LK = new K with L + val B: O.LK = new K with L + val scrut: O.LK = A + scrut match { + case B if "".isEmpty => ??? + case A => + case B => ??? + } + } +} diff --git a/test/junit/scala/reflect/internal/TypesTest.scala b/test/junit/scala/reflect/internal/TypesTest.scala new file mode 100644 index 000000000000..95194ef0a453 --- /dev/null +++ b/test/junit/scala/reflect/internal/TypesTest.scala @@ -0,0 +1,35 @@ +package scala.reflect.internal + +import org.junit.Assert._ +import org.junit.Test +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 +import scala.tools.nsc.symtab.SymbolTableForUnitTesting + +@RunWith(classOf[JUnit4]) +class TypesTest { + + object symbolTable extends SymbolTableForUnitTesting + import symbolTable._, definitions._ + + @Test + def testRefinedTypeSI8611(): Unit = { + def stringNarrowed = StringTpe.narrow + assert(stringNarrowed != stringNarrowed) + assert(!(stringNarrowed =:= stringNarrowed)) + + def boolWithString = refinedType(BooleanTpe :: StringTpe :: Nil, NoSymbol) + assert(boolWithString != boolWithString) + assert(boolWithString =:= boolWithString) + + val boolWithString1 = boolWithString + val boolWithString1narrow1 = boolWithString1.narrow + val boolWithString1narrow2 = boolWithString1.narrow + // Two narrowings of the same refinement end up =:=. This was the root + // cause of SI-8611. See `narrowUniquely` in `Logic` for the workaround. + assert(boolWithString1narrow1 =:= boolWithString1narrow2) + val uniquelyNarrowed1 = refinedType(boolWithString1narrow1 :: Nil, NoSymbol) + val uniquelyNarrowed2 = refinedType(boolWithString1narrow2 :: Nil, NoSymbol) + assert(uniquelyNarrowed1 =:= uniquelyNarrowed2) + } +} From 78caf290f86b965cc0d750d55a62ebea567d613d Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Tue, 10 Jun 2014 18:57:34 +0200 Subject: [PATCH 326/826] Remove now-redundant condition in sealedness checking It arrived in c1f8dbc, but is no longer needed after user-defined value classes were introduced in 2.10.0. --- .../scala/tools/nsc/transform/patmat/MatchAnalysis.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala index 13c7a0996a57..e1a663ea416a 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala @@ -115,7 +115,7 @@ trait TreeAndTypeAnalysis extends Debugging { ) else None // make sure it's not a primitive, else (5: Byte) match { case 5 => ... } sees no Byte - case sym if sym.isSealed && !isPrimitiveValueClass(sym) => + case sym if sym.isSealed => val subclasses = debug.patmatResult(s"enum $sym sealed, subclasses")( // symbols which are both sealed and abstract need not be covered themselves, because // all of their children must be and they cannot otherwise be created. From 1a20152e97fe772e299fa3eb2608bedcea95cb82 Mon Sep 17 00:00:00 2001 From: clhodapp Date: Thu, 29 May 2014 21:44:46 -0700 Subject: [PATCH 327/826] SI-6967 Fix ClassTag unapply for primitives This commit fixes the behavior of ClassTag's Any-accepting unapply overload. Previously, ClassTag had overloads of unapply that accepted all of the Java primitive aliases (language-supported magic classes extending AnyVal), as well as an implementation that accepted an Any. All of the AnyVal-accepting (more specific) versions of the methods worked correctly. However, the Any-accepting version incorrectly handled these types. For example, ClassTag.Int.unapply(3) would return Some(3) (through the Int-accepting overload), while ClassTag.Int.unapply(3: Any) would return None (through the Any-accepting overload). This commit unifies these behaviors, making ClassTag.Int.unapply(3: Any) return Some(3). It accomplishes this by adding a pattern match on the type of that method's argument, which will delegate to one of the more-specifically-typed overloads if possible. It also improves the formatting of the code a bit. One thing to note (though I doubt anyone will ever do this based on this message) is that the AnyVal-subtype-accepting overloads should be removed in Scala 2.12, as they are unneeded. I placed a note to this effect into the code. --- src/library/scala/reflect/ClassTag.scala | 48 ++++++++++++--------- test/files/run/t6318_primitives.check | 54 ++++++++++++++++-------- test/files/run/t6318_primitives.scala | 40 +++++++++++++----- test/files/run/virtpatmat_typetag.check | 4 +- 4 files changed, 96 insertions(+), 50 deletions(-) diff --git a/src/library/scala/reflect/ClassTag.scala b/src/library/scala/reflect/ClassTag.scala index 33c5cee783f1..bced50527325 100644 --- a/src/library/scala/reflect/ClassTag.scala +++ b/src/library/scala/reflect/ClassTag.scala @@ -70,26 +70,36 @@ trait ClassTag[T] extends ClassManifestDeprecatedApis[T] with Equals with Serial * `SomeExtractor(...)` is turned into `ct(SomeExtractor(...))` if `T` in `SomeExtractor.unapply(x: T)` * is uncheckable, but we have an instance of `ClassTag[T]`. */ - def unapply(x: Any): Option[T] = unapply_impl(x) - def unapply(x: Byte): Option[T] = unapply_impl(x) - def unapply(x: Short): Option[T] = unapply_impl(x) - def unapply(x: Char): Option[T] = unapply_impl(x) - def unapply(x: Int): Option[T] = unapply_impl(x) - def unapply(x: Long): Option[T] = unapply_impl(x) - def unapply(x: Float): Option[T] = unapply_impl(x) - def unapply(x: Double): Option[T] = unapply_impl(x) - def unapply(x: Boolean): Option[T] = unapply_impl(x) - def unapply(x: Unit): Option[T] = unapply_impl(x) + def unapply(x: Any): Option[T] = x match { + case null => None + case b: Byte => unapply(b) + case s: Short => unapply(s) + case c: Char => unapply(c) + case i: Int => unapply(i) + case l: Long => unapply(l) + case f: Float => unapply(f) + case d: Double => unapply(d) + case b: Boolean => unapply(b) + case u: Unit => unapply(u) + case a: Any => unapplyImpl(a) + } - private def unapply_impl[U: ClassTag](x: U): Option[T] = - if (x == null) None - else { - val staticClass = classTag[U].runtimeClass - val dynamicClass = x.getClass - val effectiveClass = if (staticClass.isPrimitive) staticClass else dynamicClass - val conforms = runtimeClass.isAssignableFrom(effectiveClass) - if (conforms) Some(x.asInstanceOf[T]) else None - } + // TODO: Inline the bodies of these into the Any-accepting unapply overload above and delete them. + // This cannot be done until at least 2.12.0 for reasons of binary compatibility + def unapply(x: Byte) : Option[T] = unapplyImpl(x, classOf[Byte]) + def unapply(x: Short) : Option[T] = unapplyImpl(x, classOf[Short]) + def unapply(x: Char) : Option[T] = unapplyImpl(x, classOf[Char]) + def unapply(x: Int) : Option[T] = unapplyImpl(x, classOf[Int]) + def unapply(x: Long) : Option[T] = unapplyImpl(x, classOf[Long]) + def unapply(x: Float) : Option[T] = unapplyImpl(x, classOf[Float]) + def unapply(x: Double) : Option[T] = unapplyImpl(x, classOf[Double]) + def unapply(x: Boolean) : Option[T] = unapplyImpl(x, classOf[Boolean]) + def unapply(x: Unit) : Option[T] = unapplyImpl(x, classOf[Unit]) + + private[this] def unapplyImpl(x: Any, alternative: jClass[_] = null): Option[T] = { + val conforms = runtimeClass.isAssignableFrom(x.getClass) || (alternative != null && runtimeClass.isAssignableFrom(alternative)) + if (conforms) Some(x.asInstanceOf[T]) else None + } // case class accessories override def canEqual(x: Any) = x.isInstanceOf[ClassTag[_]] diff --git a/test/files/run/t6318_primitives.check b/test/files/run/t6318_primitives.check index b330f91276aa..4bc5e598eb53 100644 --- a/test/files/run/t6318_primitives.check +++ b/test/files/run/t6318_primitives.check @@ -1,36 +1,54 @@ -true +Checking if byte matches byte Some(1) -false +Checking if byte matches short None -true +Checking if class java.lang.Byte matches byte Some(1) -false +Checking if short matches short +Some(1) +Checking if short matches char None -true +Checking if class java.lang.Short matches short +Some(1) +Checking if char matches char Some() -false +Checking if char matches int None -true +Checking if class java.lang.Character matches char +Some() +Checking if int matches int Some(1) -false +Checking if int matches long None -true +Checking if class java.lang.Integer matches int Some(1) -false +Checking if long matches long +Some(1) +Checking if long matches float None -true +Checking if class java.lang.Long matches long +Some(1) +Checking if float matches float Some(1.0) -false +Checking if float matches double None -true +Checking if class java.lang.Float matches float Some(1.0) -false +Checking if double matches double +Some(1.0) +Checking if double matches boolean None -true +Checking if class java.lang.Double matches double +Some(1.0) +Checking if boolean matches boolean Some(true) -false +Checking if boolean matches void None -true +Checking if class java.lang.Boolean matches boolean +Some(true) +Checking if void matches void Some(()) -false +Checking if void matches byte None +Checking if class scala.runtime.BoxedUnit matches void +Some(()) diff --git a/test/files/run/t6318_primitives.scala b/test/files/run/t6318_primitives.scala index 30f27120b360..bc8ec8835965 100644 --- a/test/files/run/t6318_primitives.scala +++ b/test/files/run/t6318_primitives.scala @@ -2,70 +2,88 @@ import scala.reflect.{ClassTag, classTag} object Test extends App { def test[T: ClassTag](x: T) { - println(classTag[T].runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[T].runtimeClass}") println(classTag[T].unapply(x)) } { val x = 1.toByte - println(ClassTag.Byte.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Byte].runtimeClass}") println(ClassTag.Byte.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Short].runtimeClass}") + println(ClassTag.Short.unapply(x)) test(x) } { val x = 1.toShort - println(ClassTag.Short.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Short].runtimeClass}") println(ClassTag.Short.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Char].runtimeClass}") + println(ClassTag.Char.unapply(x)) test(x) } { val x = 1.toChar - println(ClassTag.Char.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Char].runtimeClass}") println(ClassTag.Char.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Int].runtimeClass}") + println(ClassTag.Int.unapply(x)) test(x) } { val x = 1.toInt - println(ClassTag.Int.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Int].runtimeClass}") println(ClassTag.Int.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Long].runtimeClass}") + println(ClassTag.Long.unapply(x)) test(x) } { val x = 1.toLong - println(ClassTag.Long.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Long].runtimeClass}") println(ClassTag.Long.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Float].runtimeClass}") + println(ClassTag.Float.unapply(x)) test(x) } { val x = 1.toFloat - println(ClassTag.Float.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Float].runtimeClass}") println(ClassTag.Float.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Double].runtimeClass}") + println(ClassTag.Double.unapply(x)) test(x) } { val x = 1.toDouble - println(ClassTag.Double.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Double].runtimeClass}") println(ClassTag.Double.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Boolean].runtimeClass}") + println(ClassTag.Boolean.unapply(x)) test(x) } { val x = true - println(ClassTag.Boolean.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Boolean].runtimeClass}") println(ClassTag.Boolean.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Unit].runtimeClass}") + println(ClassTag.Unit.unapply(x)) test(x) } { val x = () - println(ClassTag.Unit.runtimeClass.isAssignableFrom(x.getClass)) + println(s"Checking if ${x.getClass} matches ${classTag[Unit].runtimeClass}") println(ClassTag.Unit.unapply(x)) + println(s"Checking if ${x.getClass} matches ${classTag[Byte].runtimeClass}") + println(ClassTag.Byte.unapply(x)) test(x) } -} \ No newline at end of file +} diff --git a/test/files/run/virtpatmat_typetag.check b/test/files/run/virtpatmat_typetag.check index cac9d9a4d6ed..00df8b5e81b4 100644 --- a/test/files/run/virtpatmat_typetag.check +++ b/test/files/run/virtpatmat_typetag.check @@ -1,9 +1,9 @@ -1 is not a Int; it's a class java.lang.Integer +1 is a Int 1 is a java.lang.Integer 1 is not a java.lang.String; it's a class java.lang.Integer true is a Any woele is a java.lang.String -1 is not a Int; it's a class java.lang.Integer +1 is a Int 1 is a java.lang.Integer 1 is not a java.lang.String; it's a class java.lang.Integer true is a Any From 4826d71f9f0a55c3e88847a2ae495db0f785e104 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Wed, 4 Jun 2014 14:10:08 +0200 Subject: [PATCH 328/826] SI-7372 make binarySearch methods use the same parameters for the same things. The public facing binarySearch method used an inclusive 'from' parameter, while the internal @tailrec one used an *exclusive* 'from' parameter. No wonder there was an off-by-one error somewhere. This makes both methods use the same exclusive 'from' parameter. --- src/library/scala/collection/Searching.scala | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/library/scala/collection/Searching.scala b/src/library/scala/collection/Searching.scala index 6a56410d4c54..b68124b3f8e0 100644 --- a/src/library/scala/collection/Searching.scala +++ b/src/library/scala/collection/Searching.scala @@ -54,7 +54,7 @@ object Searching { */ final def search[B >: A](elem: B)(implicit ord: Ordering[B]): SearchResult = coll match { - case _: IndexedSeq[A] => binarySearch(elem, -1, coll.length)(ord) + case _: IndexedSeq[A] => binarySearch(elem, 0, coll.length)(ord) case _ => linearSearch(coll.view, elem, 0)(ord) } @@ -81,18 +81,18 @@ object Searching { final def search[B >: A](elem: B, from: Int, to: Int) (implicit ord: Ordering[B]): SearchResult = coll match { - case _: IndexedSeq[A] => binarySearch(elem, from-1, to)(ord) + case _: IndexedSeq[A] => binarySearch(elem, from, to)(ord) case _ => linearSearch(coll.view(from, to), elem, from)(ord) } @tailrec private def binarySearch[B >: A](elem: B, from: Int, to: Int) (implicit ord: Ordering[B]): SearchResult = { - if ((to-from) == 1) InsertionPoint(from + 1) else { - val idx = from+(to-from)/2 + if (to == from) InsertionPoint(from) else { + val idx = from+(to-from-1)/2 math.signum(ord.compare(elem, coll(idx))) match { case -1 => binarySearch(elem, from, idx)(ord) - case 1 => binarySearch(elem, idx, to)(ord) + case 1 => binarySearch(elem, idx + 1, to)(ord) case _ => Found(idx) } } From f7d2cec3a0c31836747a25e3cc5949d1f3cbdff4 Mon Sep 17 00:00:00 2001 From: Max Bileschi Date: Thu, 12 Jun 2014 17:31:08 -0400 Subject: [PATCH 329/826] Update PartialFunction documentation to include the fact that the caller is responsible for checking 'isDefinedAt' --- src/library/scala/PartialFunction.scala | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/library/scala/PartialFunction.scala b/src/library/scala/PartialFunction.scala index a0b18f7f3342..7eb0f51660d4 100644 --- a/src/library/scala/PartialFunction.scala +++ b/src/library/scala/PartialFunction.scala @@ -12,7 +12,7 @@ package scala /** A partial function of type `PartialFunction[A, B]` is a unary function * where the domain does not necessarily include all values of type `A`. * The function `isDefinedAt` allows to test dynamically if a value is in - * the domain of the function. + * the domain of the function. * * Even if `isDefinedAt` returns true for an `a: A`, calling `apply(a)` may * still throw an exception, so the following code is legal: @@ -20,6 +20,12 @@ package scala * {{{ * val f: PartialFunction[Int, Any] = { case _ => 1/0 } * }}} + * + * It is the responsibility of the caller of `apply` to check for membership + * in the domain by calling `isDefinedAt`, to ensure sanity of return values. + * A notable exception to this rule is `PartialFunction`s created with curly + * braces and case statements; In this case, a [[scala.MatchError]] is + * thrown if `isDefinedAt` (i.e. pattern matching) fails. * * The main distinction between `PartialFunction` and [[scala.Function1]] is * that the user of a `PartialFunction` may choose to do something different From 455bcd65c055119f928b3367839f0093cf0e251a Mon Sep 17 00:00:00 2001 From: Max Bileschi Date: Thu, 12 Jun 2014 17:32:52 -0400 Subject: [PATCH 330/826] Update PartialFunction documentation to include the fact that the caller is responsible for checking 'isDefinedAt' --- src/library/scala/PartialFunction.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/library/scala/PartialFunction.scala b/src/library/scala/PartialFunction.scala index 7eb0f51660d4..05888921d9a6 100644 --- a/src/library/scala/PartialFunction.scala +++ b/src/library/scala/PartialFunction.scala @@ -12,7 +12,7 @@ package scala /** A partial function of type `PartialFunction[A, B]` is a unary function * where the domain does not necessarily include all values of type `A`. * The function `isDefinedAt` allows to test dynamically if a value is in - * the domain of the function. + * the domain of the function. * * Even if `isDefinedAt` returns true for an `a: A`, calling `apply(a)` may * still throw an exception, so the following code is legal: From 099a426dd6a176e704f47ed665669bf093a6d3f6 Mon Sep 17 00:00:00 2001 From: Jeroen ter Voorde Date: Wed, 14 May 2014 22:26:26 +0200 Subject: [PATCH 331/826] SI-8589 Performance improvement for ArrayCharSequence.toString --- src/library/scala/runtime/SeqCharSequence.scala | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/library/scala/runtime/SeqCharSequence.scala b/src/library/scala/runtime/SeqCharSequence.scala index d2084a659806..a7765994ecfc 100644 --- a/src/library/scala/runtime/SeqCharSequence.scala +++ b/src/library/scala/runtime/SeqCharSequence.scala @@ -41,5 +41,10 @@ final class ArrayCharSequence(val xs: Array[Char], start: Int, end: Int) extends new ArrayCharSequence(xs, start1, start1 + newlen) } } - override def toString = xs drop start take length mkString "" + override def toString = { + val start = math.max(this.start, 0) + val end = math.min(xs.length, start + length) + + if (start >= end) "" else new String(xs, start, end - start) + } } From 2238a85d732dbfd63cfd9910511aa140838933f7 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Fri, 20 Jun 2014 10:56:12 +0200 Subject: [PATCH 332/826] SI-8672 Better end-of-sentence detection for Scaladoc The first sentence of a Scaladoc comment is parsed as the summary. However, this was breaking of the sentence at the first `.`, even if that was immediately followed by another character. This commit only considers a period followed by whitespace, EOL or EOF as the end of a sentence. --- .../nsc/doc/base/CommentFactoryBase.scala | 12 ++++++- test/scaladoc/run/t8672.check | 4 +++ test/scaladoc/run/t8672.scala | 32 +++++++++++++++++++ 3 files changed, 47 insertions(+), 1 deletion(-) create mode 100644 test/scaladoc/run/t8672.check create mode 100644 test/scaladoc/run/t8672.scala diff --git a/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala b/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala index a933c35c9907..19cc27b40b0d 100755 --- a/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala +++ b/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala @@ -666,7 +666,7 @@ trait CommentFactoryBase { this: MemberLookupBase => } def summary(): Inline = { - val i = inline(check(".")) + val i = inline(checkSentenceEnded()) Summary( if (jump(".")) Chain(List(i, Text("."))) @@ -785,6 +785,16 @@ trait CommentFactoryBase { this: MemberLookupBase => }) } + def checkSentenceEnded(): Boolean = { + (char == '.') && { + val poff = offset + nextChar() // read '.' + val ok = char == endOfText || char == endOfLine || isWhitespace(char) + offset = poff + ok + } + } + def reportError(pos: Position, message: String) { reporter.warning(pos, message) } diff --git a/test/scaladoc/run/t8672.check b/test/scaladoc/run/t8672.check new file mode 100644 index 000000000000..d7194c73bf1a --- /dev/null +++ b/test/scaladoc/run/t8672.check @@ -0,0 +1,4 @@ +Some(Chain(List(Text(New in release 1.2.3.4, it works), Text(.)))) +Some(Text(Sentence no period)) +Some(Chain(List(Text(Sentence period at end), Text(.)))) +Done. diff --git a/test/scaladoc/run/t8672.scala b/test/scaladoc/run/t8672.scala new file mode 100644 index 000000000000..8a9b5086bdd6 --- /dev/null +++ b/test/scaladoc/run/t8672.scala @@ -0,0 +1,32 @@ +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocModelTest + +object Test extends ScaladocModelTest { + override def code = """ + class C { + + /** + * New in release 1.2.3.4, it works. Next sentence. + * Next Line. + */ + def method1 = 0 + + /** Sentence no period */ + def method2 = 0 + + /** Sentence period at end.*/ + def method3 = 0 + } + """ + + def scaladocSettings = "" + + def testModel(root: Package) = { + import access._ + val ms = List("method1", "method2", "method3") + for (m <- ms) { + val method = root._class("C")._method(m) + println(method.comment.get.body.summary) + } + } +} From d071abe8dd9035d8dd246ecb6b207e584b6437fa Mon Sep 17 00:00:00 2001 From: Evgeny Vereshchagin Date: Fri, 20 Jun 2014 17:04:10 +0400 Subject: [PATCH 333/826] Change StringContext scaladoc See e2a3498 commit message for explanation Explicit private declaration better than implicit Thanks to @som-snytt --- src/library/scala/StringContext.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/library/scala/StringContext.scala b/src/library/scala/StringContext.scala index c0468e8b021d..c9e632c70ecc 100644 --- a/src/library/scala/StringContext.scala +++ b/src/library/scala/StringContext.scala @@ -38,7 +38,7 @@ import scala.annotation.tailrec * To provide your own string interpolator, create an implicit class * which adds a method to `StringContext`. Here's an example: * {{{ - * implicit class JsonHelper(val sc: StringContext) extends AnyVal { + * implicit class JsonHelper(private val sc: StringContext) extends AnyVal { * def json(args: Any*): JSONObject = ... * } * val x: JSONObject = json"{ a: $a }" From 7a16f76673530f71bf1b8fa79b489b502ef504a8 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Mon, 23 Jun 2014 11:27:31 +0200 Subject: [PATCH 334/826] SI-8675 Avoid unreported error after second try using implicit view This is specific to situations in which we first typecheck an application `qual.m(arg)` against the method `m` directly provided by `qual`, and then fall back to `implicitView(qual).m(arg)`. Regressed in SI-3971 / 7fa77af, in which error reports were moved to the innermost `Apply`, and the check for `errorInResult` was accordingly changed to recurse through `Apply` trees. Before that change, we did not fall back to using a view. After the change, we do try a view. We retypecheck the arguments under the `retyping` mode (see `tryTypedArgs`), but this doesn't seem to be enough to avoid leaking the error typed nested trees from the first try. Here's an example from the enclosed test case: a.update(0, x[A]({new isString(true)})) `-- error typed refArrayOps(a).update(0, x[A]({new isString(true)})) ` `-- error type persists `-- this tree is retypecked by tryTypedArgs This commit changes `onError` to only proceed with the second try if the retyped argument trees are error free. --- .../scala/tools/nsc/typechecker/Typers.scala | 2 +- test/files/neg/t8675.check | 11 +++++++++ test/files/neg/t8675.scala | 24 +++++++++++++++++++ 3 files changed, 36 insertions(+), 1 deletion(-) create mode 100644 test/files/neg/t8675.check create mode 100644 test/files/neg/t8675.scala diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 66b1c2d87a3c..9a4d5e3c0676 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -4399,7 +4399,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper if (retry) { val Select(qual, name) = fun tryTypedArgs(args, forArgMode(fun, mode)) match { - case Some(args1) => + case Some(args1) if !args1.exists(arg => arg.exists(_.isErroneous)) => val qual1 = if (!pt.isError) adaptToArguments(qual, name, args1, pt, reportAmbiguous = true, saveErrors = true) else qual diff --git a/test/files/neg/t8675.check b/test/files/neg/t8675.check new file mode 100644 index 000000000000..4e44fba91867 --- /dev/null +++ b/test/files/neg/t8675.check @@ -0,0 +1,11 @@ +t8675.scala:13: error: type mismatch; + found : Boolean(true) + required: String + a.update(0, x[A]({new isString(true)})) // !!! allowed + ^ +t8675.scala:22: error: type mismatch; + found : Boolean(true) + required: String + new X().m(x[A]({new isString(true)})) // !!! allowed + ^ +two errors found diff --git a/test/files/neg/t8675.scala b/test/files/neg/t8675.scala new file mode 100644 index 000000000000..ca9bb57ffaa8 --- /dev/null +++ b/test/files/neg/t8675.scala @@ -0,0 +1,24 @@ +class A(s: String) { + def foo(x: A) = x +} + +class isString(s: String) + +class Test { + + def x[A](a: Any): A = ??? + + def test { + val a = Array[A]() + a.update(0, x[A]({new isString(true)})) // !!! allowed + + // boils down to + class X { + def m(p: Any) {} + } + implicit class XOps(x: X) { + def m(p: Any) {} + } + new X().m(x[A]({new isString(true)})) // !!! allowed + } +} From 299594e63a925c3e6042c6fd920de2f359417cbd Mon Sep 17 00:00:00 2001 From: Johannes Rudolph Date: Wed, 25 Jun 2014 13:40:13 +0200 Subject: [PATCH 335/826] SI-8657 don't miss tailrec defs in more positions 1) First operand of boolean expression using `&&` or `||`. Second operands of those boolean exprs were already treated specially here but handling for first operands was missing. 2) Condition of `If`. Also added a test for guards. --- .../scala/tools/nsc/transform/TailCalls.scala | 7 ++-- test/files/neg/tailrec-4.check | 16 +++++++++ test/files/neg/tailrec-4.scala | 35 +++++++++++++++++++ test/files/run/tailcalls.check | 8 +++++ test/files/run/tailcalls.scala | 35 +++++++++++++++++-- 5 files changed, 97 insertions(+), 4 deletions(-) create mode 100644 test/files/neg/tailrec-4.check create mode 100644 test/files/neg/tailrec-4.scala diff --git a/src/compiler/scala/tools/nsc/transform/TailCalls.scala b/src/compiler/scala/tools/nsc/transform/TailCalls.scala index 714f189ead05..d9d1192772fa 100644 --- a/src/compiler/scala/tools/nsc/transform/TailCalls.scala +++ b/src/compiler/scala/tools/nsc/transform/TailCalls.scala @@ -328,11 +328,14 @@ abstract class TailCalls extends Transform { ) case CaseDef(pat, guard, body) => + // CaseDefs are already translated and guards were moved into the body. + // If this was not the case, guards would have to be transformed here as well. + assert(guard.isEmpty) deriveCaseDef(tree)(transform) case If(cond, thenp, elsep) => treeCopy.If(tree, - cond, + noTailTransform(cond), transform(thenp), transform(elsep) ) @@ -363,7 +366,7 @@ abstract class TailCalls extends Transform { rewriteApply(tapply, fun, targs, vargs) case Apply(fun, args) if fun.symbol == Boolean_or || fun.symbol == Boolean_and => - treeCopy.Apply(tree, fun, transformTrees(args)) + treeCopy.Apply(tree, noTailTransform(fun), transformTrees(args)) // this is to detect tailcalls in translated matches // it's a one-argument call to a label that is in a tailposition and that looks like label(x) {x} diff --git a/test/files/neg/tailrec-4.check b/test/files/neg/tailrec-4.check new file mode 100644 index 000000000000..3ec32744780e --- /dev/null +++ b/test/files/neg/tailrec-4.check @@ -0,0 +1,16 @@ +tailrec-4.scala:6: error: could not optimize @tailrec annotated method foo: it contains a recursive call not in tail position + @tailrec def foo: Int = foo + 1 + ^ +tailrec-4.scala:11: error: could not optimize @tailrec annotated method foo: it contains a recursive call not in tail position + @tailrec def foo: Int = foo + 1 + ^ +tailrec-4.scala:17: error: could not optimize @tailrec annotated method foo: it contains a recursive call not in tail position + @tailrec def foo: Int = foo + 1 + ^ +tailrec-4.scala:23: error: could not optimize @tailrec annotated method foo: it contains a recursive call not in tail position + @tailrec def foo: Int = foo + 1 + ^ +tailrec-4.scala:31: error: could not optimize @tailrec annotated method foo: it contains a recursive call not in tail position + @tailrec def foo: Int = foo + 1 + ^ +5 errors found diff --git a/test/files/neg/tailrec-4.scala b/test/files/neg/tailrec-4.scala new file mode 100644 index 000000000000..4822799dfa07 --- /dev/null +++ b/test/files/neg/tailrec-4.scala @@ -0,0 +1,35 @@ +import annotation._ + +object Tail { + def tcInFunc: Unit = { + () => { + @tailrec def foo: Int = foo + 1 + } + } + def tcInBooleanExprFirstOp(x: Int, v: Int): Boolean = { + { + @tailrec def foo: Int = foo + 1 + foo + } == v && true + } + def tcInBooleanExprSecondOp(x: Int, v: Int): Boolean = { + true && { + @tailrec def foo: Int = foo + 1 + foo + } == v + } + def tcInIfCond(x: Int, v: Int): Boolean = { + if ({ + @tailrec def foo: Int = foo + 1 + foo + } == v) true else false + } + def tcInPatternGuard(x: Int, v: Int): Boolean = + v match { + case _ if + { + @tailrec def foo: Int = foo + 1 + foo == 42 + } => true + } +} diff --git a/test/files/run/tailcalls.check b/test/files/run/tailcalls.check index 7607921856ff..92d4f8a3c863 100644 --- a/test/files/run/tailcalls.check +++ b/test/files/run/tailcalls.check @@ -50,6 +50,10 @@ test NonTailCall.f2 test TailCall.b1 was successful test TailCall.b2 was successful test FancyTailCalls.tcTryLocal was successful +test FancyTailCalls.tcInBooleanExprFirstOp was successful +test FancyTailCalls.tcInBooleanExprSecondOp was successful +test FancyTailCalls.tcInIfCond was successful +test FancyTailCalls.tcInPatternGuard was successful test FancyTailCalls.differentInstance was successful test PolyObject.tramp was successful #partest avian @@ -104,5 +108,9 @@ test NonTailCall.f2 test TailCall.b1 was successful test TailCall.b2 was successful test FancyTailCalls.tcTryLocal was successful +test FancyTailCalls.tcInBooleanExprFirstOp was successful +test FancyTailCalls.tcInBooleanExprSecondOp was successful +test FancyTailCalls.tcInIfCond was successful +test FancyTailCalls.tcInPatternGuard was successful test FancyTailCalls.differentInstance was successful test PolyObject.tramp was successful diff --git a/test/files/run/tailcalls.scala b/test/files/run/tailcalls.scala index 1653b14de9c6..8df2dcfcb635 100644 --- a/test/files/run/tailcalls.scala +++ b/test/files/run/tailcalls.scala @@ -213,6 +213,33 @@ class FancyTailCalls { } finally {} } + def tcInBooleanExprFirstOp(x: Int, v: Int): Boolean = { + { + def loop(n: Int): Int = if (n == 0) v else loop(n - 1) + loop(x) + } == v && true + } + def tcInBooleanExprSecondOp(x: Int, v: Int): Boolean = { + true && { + def loop(n: Int): Int = if (n == 0) v else loop(n - 1) + loop(x) + } == v + } + def tcInIfCond(x: Int, v: Int): Boolean = { + if ({ + def loop(n: Int): Int = if (n == 0) v else loop(n - 1) + loop(x) + } == v) true else false + } + def tcInPatternGuard(x: Int, v: Int): Boolean = + v match { + case _ if + { + def loop(n: Int): Int = if (n == 0) v else loop(n - 1) + loop(x) == v + } => true + } + import FancyTailCalls._ final def differentInstance(n: Int, v: Int): Int = { if (n == 0) v @@ -376,8 +403,12 @@ object Test { check_success_b("TailCall.b2", TailCall.b2(max), true) val FancyTailCalls = new FancyTailCalls; - check_success("FancyTailCalls.tcTryLocal", FancyTailCalls.tcTryLocal(max, max), max) - check_success("FancyTailCalls.differentInstance", FancyTailCalls.differentInstance(max, 42), 42) + check_success("FancyTailCalls.tcTryLocal", FancyTailCalls.tcTryLocal(max, max), max) + check_success_b("FancyTailCalls.tcInBooleanExprFirstOp", FancyTailCalls.tcInBooleanExprFirstOp(max, max), true) + check_success_b("FancyTailCalls.tcInBooleanExprSecondOp", FancyTailCalls.tcInBooleanExprSecondOp(max, max), true) + check_success_b("FancyTailCalls.tcInIfCond", FancyTailCalls.tcInIfCond(max, max), true) + check_success_b("FancyTailCalls.tcInPatternGuard", FancyTailCalls.tcInPatternGuard(max, max), true) + check_success("FancyTailCalls.differentInstance", FancyTailCalls.differentInstance(max, 42), 42) check_success("PolyObject.tramp", PolyObject.tramp[Int](max), 0) } From 5ba129070f46da9b981d36afe2f9f0aac50c3800 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Thu, 26 Jun 2014 11:32:01 +0200 Subject: [PATCH 336/826] SI-8675 Add another test case for swallowed type errors As reported on scala-internals. After tightening up the treatment of undetermined type parameters in SI-7944, the enclosed test case no longer typechecks. And since the regression fixed in the previous commit, the error was swallowed by the typechecker only to be burped up by a crash in the backend. --- test/files/neg/t8675b.check | 6 ++++++ test/files/neg/t8675b.scala | 22 ++++++++++++++++++++++ 2 files changed, 28 insertions(+) create mode 100644 test/files/neg/t8675b.check create mode 100644 test/files/neg/t8675b.scala diff --git a/test/files/neg/t8675b.check b/test/files/neg/t8675b.check new file mode 100644 index 000000000000..cb7ac8af59a1 --- /dev/null +++ b/test/files/neg/t8675b.check @@ -0,0 +1,6 @@ +t8675b.scala:19: error: missing parameter type for expanded function +The argument types of an anonymous function must be fully known. (SLS 8.5) +Expected type was: List[Test.Reportable1[?,?]] => Boolean + for (path: List[Any] <- (null : Engine1).asRequirement.pathsIncludingSelf.toList) { + ^ +one error found diff --git a/test/files/neg/t8675b.scala b/test/files/neg/t8675b.scala new file mode 100644 index 000000000000..2c5015b1d0a8 --- /dev/null +++ b/test/files/neg/t8675b.scala @@ -0,0 +1,22 @@ +object Test { + trait Engine1 + + implicit class EngineTools1[Params, R](e: Engine1) { + def asRequirement: Requirement1[Params, R] = ??? + } + trait Requirement1[Params, R] { + def pathsIncludingSelf: Traversable[List[Reportable1[Params, R]]] + } + trait Reportable1[Params, R] + + // "missing paramater type" error was swallowed in 2.11.0 leading to a crash + // in the backend. + // + // This error is itself a regression (or at least a change) in 2.11.0-M7, + // specifically in SI-7944. The type paramaters to the implicit view + // `EngineTools1` are undetermined, and are now treated as type variables + // in the expected type of the closure argument to `withFilter`. + for (path: List[Any] <- (null : Engine1).asRequirement.pathsIncludingSelf.toList) { + ??? + } +} From 1f53a0d180a1fa561502f3d7884d71daf998a837 Mon Sep 17 00:00:00 2001 From: Rex Kerr Date: Thu, 26 Jun 2014 18:07:57 -0700 Subject: [PATCH 337/826] SI-7577 Incorrect documentation: current default isn't Vector Fixed documentation to specify List in four cases where it was wrong or missing. --- src/library/scala/collection/Iterable.scala | 2 +- src/library/scala/collection/Traversable.scala | 2 +- src/library/scala/collection/immutable/Iterable.scala | 1 + src/library/scala/collection/immutable/Traversable.scala | 2 +- 4 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/library/scala/collection/Iterable.scala b/src/library/scala/collection/Iterable.scala index a5ab8efd5c2d..afbffd36c694 100644 --- a/src/library/scala/collection/Iterable.scala +++ b/src/library/scala/collection/Iterable.scala @@ -38,7 +38,7 @@ trait Iterable[+A] extends Traversable[A] } /** $factoryInfo - * The current default implementation of a $Coll is a `Vector`. + * The current default implementation of a $Coll is a `List`. * @define coll iterable collection * @define Coll `Iterable` */ diff --git a/src/library/scala/collection/Traversable.scala b/src/library/scala/collection/Traversable.scala index b53724c5683c..a35750a35f9f 100644 --- a/src/library/scala/collection/Traversable.scala +++ b/src/library/scala/collection/Traversable.scala @@ -87,7 +87,7 @@ trait Traversable[+A] extends TraversableLike[A, Traversable[A]] } /** $factoryInfo - * The current default implementation of a $Coll is a `Vector`. + * The current default implementation of a $Coll is a `List`. */ object Traversable extends TraversableFactory[Traversable] { self => diff --git a/src/library/scala/collection/immutable/Iterable.scala b/src/library/scala/collection/immutable/Iterable.scala index 6e4eb1e45fa4..df322396d0c6 100644 --- a/src/library/scala/collection/immutable/Iterable.scala +++ b/src/library/scala/collection/immutable/Iterable.scala @@ -35,6 +35,7 @@ trait Iterable[+A] extends Traversable[A] } /** $factoryInfo + * The current default implementation of a $Coll is a `List`. * @define Coll `immutable.Iterable` * @define coll immutable iterable collection */ diff --git a/src/library/scala/collection/immutable/Traversable.scala b/src/library/scala/collection/immutable/Traversable.scala index 775d635faefa..5fc0607a0072 100644 --- a/src/library/scala/collection/immutable/Traversable.scala +++ b/src/library/scala/collection/immutable/Traversable.scala @@ -29,7 +29,7 @@ trait Traversable[+A] extends scala.collection.Traversable[A] } /** $factoryInfo - * The current default implementation of a $Coll is a `Vector`. + * The current default implementation of a $Coll is a `List`. * @define coll immutable traversable collection * @define Coll `immutable.Traversable` */ From c51c5e14607ac78046f8610f61abcadc6262c340 Mon Sep 17 00:00:00 2001 From: Rex Kerr Date: Thu, 26 Jun 2014 19:01:10 -0700 Subject: [PATCH 338/826] SI-7562 Regex.findAllIn does not report all matches Changed findAllIn docs to clarify that it finds non-overlapping matches. --- src/library/scala/util/matching/Regex.scala | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/library/scala/util/matching/Regex.scala b/src/library/scala/util/matching/Regex.scala index 6743b9e42a33..f35ea566bab0 100644 --- a/src/library/scala/util/matching/Regex.scala +++ b/src/library/scala/util/matching/Regex.scala @@ -274,12 +274,18 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends // @see UnanchoredRegex protected def runMatcher(m: Matcher) = m.matches() - /** Return all matches of this regexp in given character sequence as a [[scala.util.matching.Regex.MatchIterator]], + /** Return all non-overlapping matches of this regexp in given character + * sequence as a [[scala.util.matching.Regex.MatchIterator]], * which is a special [[scala.collection.Iterator]] that returns the * matched strings, but can also be converted into a normal iterator * that returns objects of type [[scala.util.matching.Regex.Match]] * that can be queried for data such as the text that precedes the * match, subgroups, etc. + * + * Where potential matches overlap, the first possible match is returned, + * followed by the next match that is completely after the first. For + * instance, `"hat[^a]+".r` will match `hath` and `hattth` in the string + * `"hathatthattthatttt"`. * * Attempting to retrieve information about a match before initializing * the iterator can result in [[java.lang.IllegalStateException]]s. See @@ -292,7 +298,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends def findAllIn(source: CharSequence) = new Regex.MatchIterator(source, this, groupNames) - /** Return all matches of this regexp in given character sequence as a + /** Return all non-overlapping matches of this regexp in given character sequence as a * [[scala.collection.Iterator]] of [[scala.util.matching.Regex.Match]]. * * @param source The text to match against. From eb2ec76d9ca9cc9eeab9c5631de4f23ae7622040 Mon Sep 17 00:00:00 2001 From: Erlend Hamnaberg Date: Fri, 27 Jun 2014 11:21:50 +0200 Subject: [PATCH 339/826] scala.io.Source now implements java.io.Closeable allows users to write a single function for dealing with Input/Output streams and Sources. It also allows Source to be used in "try-with-resources" statements in Java > 7. No tests since this is a binary and source compatible change. --- src/library/scala/io/Source.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/library/scala/io/Source.scala b/src/library/scala/io/Source.scala index 74c3e0683983..dbd6a5f6f264 100644 --- a/src/library/scala/io/Source.scala +++ b/src/library/scala/io/Source.scala @@ -10,7 +10,7 @@ package scala package io import scala.collection.AbstractIterator -import java.io.{ FileInputStream, InputStream, PrintStream, File => JFile } +import java.io.{ FileInputStream, InputStream, PrintStream, File => JFile, Closeable } import java.net.{ URI, URL } /** This object provides convenience methods to create an iterable @@ -176,7 +176,7 @@ object Source { * @author Burak Emir * @version 1.0 */ -abstract class Source extends Iterator[Char] { +abstract class Source extends Iterator[Char] with Closeable { /** the actual iterator */ protected val iter: Iterator[Char] From 71bc2e5f4c49463a754a6f23e3abd2d27467fca4 Mon Sep 17 00:00:00 2001 From: Max Bileschi Date: Fri, 27 Jun 2014 11:44:55 -0400 Subject: [PATCH 340/826] Revised comment to appeal to lchoran's and som-snytts comments --- src/library/scala/PartialFunction.scala | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/library/scala/PartialFunction.scala b/src/library/scala/PartialFunction.scala index 05888921d9a6..045ea319d922 100644 --- a/src/library/scala/PartialFunction.scala +++ b/src/library/scala/PartialFunction.scala @@ -21,11 +21,10 @@ package scala * val f: PartialFunction[Int, Any] = { case _ => 1/0 } * }}} * - * It is the responsibility of the caller of `apply` to check for membership - * in the domain by calling `isDefinedAt`, to ensure sanity of return values. - * A notable exception to this rule is `PartialFunction`s created with curly - * braces and case statements; In this case, a [[scala.MatchError]] is - * thrown if `isDefinedAt` (i.e. pattern matching) fails. + * It is the responsibility of the caller to call `isDefinedAt` before + * before calling `apply`, because if `isDefinedAt` is false, an exception + * may or may not be thrown. In the case that an exception is not thrown, + * an insane value may be returned. * * The main distinction between `PartialFunction` and [[scala.Function1]] is * that the user of a `PartialFunction` may choose to do something different From 36ef5c374a11f881cb77bcb784af7b52483ee646 Mon Sep 17 00:00:00 2001 From: Rex Kerr Date: Fri, 27 Jun 2014 19:23:37 -0700 Subject: [PATCH 341/826] SI-8638 Empty UnrolledBuffer hangs on prepend. Tracked down bug to incorrect recursion in insertAll. Fixed by adding a missing case (which incidentally will provide better performance when adding to the end of a block). No specific tests, as this is caught by quasi-complete collections tests. --- .../collection/mutable/UnrolledBuffer.scala | 48 +++++++++++-------- 1 file changed, 27 insertions(+), 21 deletions(-) diff --git a/src/library/scala/collection/mutable/UnrolledBuffer.scala b/src/library/scala/collection/mutable/UnrolledBuffer.scala index 1f89199bdcd9..693c47d86ecd 100644 --- a/src/library/scala/collection/mutable/UnrolledBuffer.scala +++ b/src/library/scala/collection/mutable/UnrolledBuffer.scala @@ -300,27 +300,33 @@ object UnrolledBuffer extends ClassTagTraversableFactory[UnrolledBuffer] { if (next eq null) true else false // checks if last node was thrown out } else false - @tailrec final def insertAll(idx: Int, t: scala.collection.Traversable[T], buffer: UnrolledBuffer[T]): Unit = if (idx < size) { - // divide this node at the appropriate position and insert all into head - // update new next - val newnextnode = new Unrolled[T](0, new Array(array.length), null, buff) - Array.copy(array, idx, newnextnode.array, 0, size - idx) - newnextnode.size = size - idx - newnextnode.next = next - - // update this - nullout(idx, size) - size = idx - next = null - - // insert everything from iterable to this - var curr = this - for (elem <- t) curr = curr append elem - curr.next = newnextnode - - // try to merge the last node of this with the newnextnode - if (curr.tryMergeWithNext()) buffer.lastPtr = curr - } else insertAll(idx - size, t, buffer) + @tailrec final def insertAll(idx: Int, t: scala.collection.Traversable[T], buffer: UnrolledBuffer[T]): Unit = { + if (idx < size) { + // divide this node at the appropriate position and insert all into head + // update new next + val newnextnode = new Unrolled[T](0, new Array(array.length), null, buff) + Array.copy(array, idx, newnextnode.array, 0, size - idx) + newnextnode.size = size - idx + newnextnode.next = next + + // update this + nullout(idx, size) + size = idx + next = null + + // insert everything from iterable to this + var curr = this + for (elem <- t) curr = curr append elem + curr.next = newnextnode + + // try to merge the last node of this with the newnextnode + if (curr.tryMergeWithNext()) buffer.lastPtr = curr + } + else if (idx == size) { + var curr = this + for (elem <- t) curr = curr append elem + } else insertAll(idx - size, t, buffer) + } private def nullout(from: Int, until: Int) { var idx = from while (idx < until) { From 23ae5c48b3c647361a63373c4f967022351d99dc Mon Sep 17 00:00:00 2001 From: Rex Kerr Date: Fri, 27 Jun 2014 19:56:17 -0700 Subject: [PATCH 342/826] SI-5200 Incorrect advice for implementing mutable.Set in scaladoc Fixed advice; it was already there in mutable.SetLike but a case sensitivity error kept it from appearing. --- src/library/scala/collection/SetLike.scala | 7 +++---- .../scala/collection/mutable/SetLike.scala | 17 +++++++++-------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/library/scala/collection/SetLike.scala b/src/library/scala/collection/SetLike.scala index 0c5c7e0b29ce..3e549f72cd8f 100644 --- a/src/library/scala/collection/SetLike.scala +++ b/src/library/scala/collection/SetLike.scala @@ -17,6 +17,9 @@ import parallel.ParSet /** A template trait for sets. * * $setNote + * '''Implementation note:''' + * This trait provides most of the operations of a `Set` independently of its representation. + * It is typically inherited by concrete implementations of sets. * $setTags * @since 2.8 * @@ -24,10 +27,6 @@ import parallel.ParSet * * A set is a collection that contains no duplicate elements. * - * '''Implementation note:''' - * This trait provides most of the operations of a `Set` independently of its representation. - * It is typically inherited by concrete implementations of sets. - * * To implement a concrete set, you need to provide implementations of the * following methods: * {{{ diff --git a/src/library/scala/collection/mutable/SetLike.scala b/src/library/scala/collection/mutable/SetLike.scala index d749167870eb..a377b03124c1 100644 --- a/src/library/scala/collection/mutable/SetLike.scala +++ b/src/library/scala/collection/mutable/SetLike.scala @@ -16,19 +16,20 @@ import scala.annotation.migration import parallel.mutable.ParSet /** A template trait for mutable sets of type `mutable.Set[A]`. + * + * This trait provides most of the operations of a `mutable.Set` independently of its representation. + * It is typically inherited by concrete implementations of sets. + * + * $setNote + * * @tparam A the type of the elements of the set * @tparam This the type of the set itself. * - * $setnote - * * @author Martin Odersky * @version 2.8 * @since 2.8 * - * @define setnote - * @note - * This trait provides most of the operations of a `mutable.Set` independently of its representation. - * It is typically inherited by concrete implementations of sets. + * @define setNote * * To implement a concrete mutable set, you need to provide implementations * of the following methods: @@ -36,13 +37,13 @@ import parallel.mutable.ParSet * def contains(elem: A): Boolean * def iterator: Iterator[A] * def += (elem: A): this.type - * def -= (elem: A): this.type + * def -= (elem: A): this.type * }}} * If you wish that methods like `take`, * `drop`, `filter` return the same kind of set, * you should also override: * {{{ - * def empty: This + * def empty: This * }}} * It is also good idea to override methods `foreach` and * `size` for efficiency. From ff43de9f8f9e0e9fef55a825dfb067bdc61b90fc Mon Sep 17 00:00:00 2001 From: Rex Kerr Date: Fri, 27 Jun 2014 20:30:33 -0700 Subject: [PATCH 343/826] SI-8335 List.++ avoidably burns memory Changed to check the identity of the CanBuildFrom instead of the identity of the generated builder to shortcut building. Should reduce memory churn on ++ a little. --- src/library/scala/collection/immutable/List.scala | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/library/scala/collection/immutable/List.scala b/src/library/scala/collection/immutable/List.scala index 930e13a9d363..aa9dec276122 100644 --- a/src/library/scala/collection/immutable/List.scala +++ b/src/library/scala/collection/immutable/List.scala @@ -190,11 +190,9 @@ sealed abstract class List[+A] extends AbstractSeq[A] // Overridden methods from IterableLike and SeqLike or overloaded variants of such methods - override def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[List[A], B, That]): That = { - val b = bf(this) - if (b.isInstanceOf[ListBuffer[_]]) (this ::: that.seq.toList).asInstanceOf[That] + override def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[List[A], B, That]): That = + if (bf eq List.ReusableCBF) (this ::: that.seq.toList).asInstanceOf[That] else super.++(that) - } override def +:[B >: A, That](elem: B)(implicit bf: CanBuildFrom[List[A], B, That]): That = bf match { case _: List.GenericCanBuildFrom[_] => (elem :: this).asInstanceOf[That] From dead39dc5f21c6eac41788e93426c50ddd398c24 Mon Sep 17 00:00:00 2001 From: "Paolo G. Giarrusso" Date: Tue, 24 Jun 2014 05:18:20 +0200 Subject: [PATCH 344/826] SI-8677 Duration: Zero - Inf should be MinusInf Fixes #8677. Add basic tests. --- src/library/scala/concurrent/duration/Duration.scala | 2 +- test/files/jvm/duration-tck.scala | 5 +++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/src/library/scala/concurrent/duration/Duration.scala b/src/library/scala/concurrent/duration/Duration.scala index 1b50b7fa5672..2eded9f06090 100644 --- a/src/library/scala/concurrent/duration/Duration.scala +++ b/src/library/scala/concurrent/duration/Duration.scala @@ -621,7 +621,7 @@ final class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duratio } def -(other: Duration) = other match { case x: FiniteDuration => add(-x.length, x.unit) - case _ => other + case _ => -other } def *(factor: Double) = diff --git a/test/files/jvm/duration-tck.scala b/test/files/jvm/duration-tck.scala index 3bc8a2c1006d..7db6c49964e2 100644 --- a/test/files/jvm/duration-tck.scala +++ b/test/files/jvm/duration-tck.scala @@ -61,6 +61,11 @@ object Test extends App { minf - inf mustBe minf minf + minf mustBe minf + for (i <- Seq(zero, one, two, three)) { + i - inf mustBe minf + i - minf mustBe inf + } + inf.compareTo(inf) mustBe 0 inf.compareTo(one) mustBe 1 inf.compareTo(minf) mustBe 1 From 9ceab680a315cb79d4d187f977e9dac3b58e48c0 Mon Sep 17 00:00:00 2001 From: Rex Kerr Date: Fri, 27 Jun 2014 17:12:39 -0700 Subject: [PATCH 345/826] SI-7115 JMapWrapper.get can incorrectly return Some(null) This isn't incorrect. Trying to use a single-threaded interface in a concurrent context is supposed to break in various unpleasant ways. Documentation has been added to encourage one to avoid wrapping a concurrent map in the generic wrapper (which assumes a single thread), and pointing out that synchronized maps do not maintain synchronization for non-atomic operations (including get). More docs. --- .../scala/collection/convert/DecorateAsScala.scala | 6 ++++++ .../scala/collection/convert/WrapAsScala.scala | 8 +++++++- src/library/scala/collection/convert/Wrappers.scala | 11 +++++++++++ 3 files changed, 24 insertions(+), 1 deletion(-) diff --git a/src/library/scala/collection/convert/DecorateAsScala.scala b/src/library/scala/collection/convert/DecorateAsScala.scala index c724831c5427..5448f5f91c8d 100644 --- a/src/library/scala/collection/convert/DecorateAsScala.scala +++ b/src/library/scala/collection/convert/DecorateAsScala.scala @@ -135,6 +135,12 @@ trait DecorateAsScala { * If the Java `Map` was previously obtained from an implicit or explicit * call of `asMap(scala.collection.mutable.Map)` then the original * Scala `Map` will be returned. + * + * If the wrapped map is synchronized (e.g. from `java.util.Collections.synchronizedMap`), + * it is your responsibility to wrap all + * non-atomic operations with `underlying.synchronized`. + * This includes `get`, as `java.util.Map`'s API does not allow for an + * atomic `get` when `null` values may be present. * * @param m The `Map` to be converted. * @return An object with an `asScala` method that returns a Scala mutable diff --git a/src/library/scala/collection/convert/WrapAsScala.scala b/src/library/scala/collection/convert/WrapAsScala.scala index d4ab451b0d28..ab151a677824 100644 --- a/src/library/scala/collection/convert/WrapAsScala.scala +++ b/src/library/scala/collection/convert/WrapAsScala.scala @@ -133,7 +133,13 @@ trait WrapAsScala { * If the Java `Map` was previously obtained from an implicit or * explicit call of `mapAsScalaMap(scala.collection.mutable.Map)` then * the original Scala Map will be returned. - * + * + * If the wrapped map is synchronized (e.g. from `java.util.Collections.synchronizedMap`), + * it is your responsibility to wrap all + * non-atomic operations with `underlying.synchronized`. + * This includes `get`, as `java.util.Map`'s API does not allow for an + * atomic `get` when `null` values may be present. + * * @param m The Map to be converted. * @return A Scala mutable Map view of the argument. */ diff --git a/src/library/scala/collection/convert/Wrappers.scala b/src/library/scala/collection/convert/Wrappers.scala index 7d1d6b3781d6..9f9732c62f4d 100644 --- a/src/library/scala/collection/convert/Wrappers.scala +++ b/src/library/scala/collection/convert/Wrappers.scala @@ -288,6 +288,13 @@ private[collection] trait Wrappers { override def empty: Repr = null.asInstanceOf[Repr] } + /** Wraps a Java map as a Scala one. If the map is to support concurrent access, + * use [[JConcurrentMapWrapper]] instead. If the wrapped map is synchronized + * (e.g. from `java.util.Collections.synchronizedMap`), it is your responsibility + * to wrap all non-atomic operations with `underlying.synchronized`. + * This includes `get`, as `java.util.Map`'s API does not allow for an + * atomic `get` when `null` values may be present. + */ case class JMapWrapper[A, B](underlying : ju.Map[A, B]) extends mutable.AbstractMap[A, B] with JMapWrapperLike[A, B, JMapWrapper[A, B]] { override def empty = JMapWrapper(new ju.HashMap[A, B]) } @@ -314,6 +321,10 @@ private[collection] trait Wrappers { def replace(k: A, oldval: B, newval: B) = underlying.replace(k, oldval, newval) } + /** Wraps a concurrent Java map as a Scala one. Single-element concurrent + * access is supported; multi-element operations such as maps and filters + * are not guaranteed to be atomic. + */ case class JConcurrentMapWrapper[A, B](underlying: juc.ConcurrentMap[A, B]) extends mutable.AbstractMap[A, B] with JMapWrapperLike[A, B, JConcurrentMapWrapper[A, B]] with concurrent.Map[A, B] { override def get(k: A) = { val v = underlying get k From 4e29e9a229c5a13e8517fe034668aa97ae102eec Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Sun, 29 Jun 2014 16:42:14 +0200 Subject: [PATCH 346/826] SI-8690 BufferedSource.mkString mistakenly skipped the first char. mkString is overriden in BufferedSource for performance, but the implementation always used the wrong reader. This seems to be a typo (`allReader` is declared 5 lines earlier but never used, `charReader` is used in its place). --- src/library/scala/io/BufferedSource.scala | 2 +- test/files/run/t8690.check | 2 ++ test/files/run/t8690.scala | 12 ++++++++++++ 3 files changed, 15 insertions(+), 1 deletion(-) create mode 100644 test/files/run/t8690.check create mode 100644 test/files/run/t8690.scala diff --git a/src/library/scala/io/BufferedSource.scala b/src/library/scala/io/BufferedSource.scala index 1c87a1f42166..52fa525b2425 100644 --- a/src/library/scala/io/BufferedSource.scala +++ b/src/library/scala/io/BufferedSource.scala @@ -93,7 +93,7 @@ class BufferedSource(inputStream: InputStream, bufferSize: Int)(implicit val cod val buf = new Array[Char](bufferSize) var n = 0 while (n != -1) { - n = charReader.read(buf) + n = allReader.read(buf) if (n>0) sb.appendAll(buf, 0, n) } sb.result diff --git a/test/files/run/t8690.check b/test/files/run/t8690.check new file mode 100644 index 000000000000..72f076c4d88e --- /dev/null +++ b/test/files/run/t8690.check @@ -0,0 +1,2 @@ +non-empty iterator +abcdef diff --git a/test/files/run/t8690.scala b/test/files/run/t8690.scala new file mode 100644 index 000000000000..ab8b45b2a76f --- /dev/null +++ b/test/files/run/t8690.scala @@ -0,0 +1,12 @@ +import scala.io.Source +import java.io.ByteArrayInputStream + +object Test extends App { + val txt = "abcdef" + + val in = new ByteArrayInputStream(txt.getBytes()); + val source = Source.fromInputStream(in); + println(source.toString) // forces the BufferedSource to look at the head of the input + + println(source.mkString) // used to return "bcdef" ... +} From 5d63ef31c16511df5ce9cbda5d07fd7672844ae2 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Sun, 16 Feb 2014 14:54:10 +0100 Subject: [PATCH 347/826] SI-8292 report error when scaladoc fails to find doclet. --- src/scaladoc/scala/tools/nsc/doc/DocFactory.scala | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/scaladoc/scala/tools/nsc/doc/DocFactory.scala b/src/scaladoc/scala/tools/nsc/doc/DocFactory.scala index dce52af56a2e..47ddfb8aa9e4 100644 --- a/src/scaladoc/scala/tools/nsc/doc/DocFactory.scala +++ b/src/scaladoc/scala/tools/nsc/doc/DocFactory.scala @@ -95,11 +95,11 @@ class DocFactory(val reporter: Reporter, val settings: doc.Settings) { processor val documentError: PartialFunction[Throwable, Unit] = { case NoCompilerRunException => reporter.info(null, "No documentation generated with unsuccessful compiler run", force = false) - case _: ClassNotFoundException => - () + case e @ (_:ClassNotFoundException | _:IllegalAccessException | _:InstantiationException | _:SecurityException | _:ClassCastException) => + reporter.error(null, s"Cannot load the doclet class ${settings.docgenerator.value} (specified with ${settings.docgenerator.name}): $e. Leaving the default settings will generate the html version of scaladoc.") } - /** Generate document(s) for all `files` containing scaladoc documenataion. + /** Generate document(s) for all `files` containing scaladoc documentation. * @param files The list of paths (relative to the compiler's source path, or absolute) of files to document. */ def document(files: List[String]) { def generate() = { From 6c698089aeb55e649a65dd7ae1bce2b4514ee865 Mon Sep 17 00:00:00 2001 From: jxcoder Date: Wed, 2 Jul 2014 15:33:18 +0700 Subject: [PATCH 348/826] Added example to Option.collect method. --- src/library/scala/Option.scala | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/library/scala/Option.scala b/src/library/scala/Option.scala index 905e925f578f..5a1c832faead 100644 --- a/src/library/scala/Option.scala +++ b/src/library/scala/Option.scala @@ -251,6 +251,17 @@ sealed abstract class Option[+A] extends Product with Serializable { * nonempty '''and''' `pf` is defined for that value. * Returns $none otherwise. * + * @example {{{ + * // Returns Some(HTTP) because the partial function covers the case. + * Some("http").collect({case "http" => "HTTP"}) + * + * // Returns None because the partial function doesn't cover the case. + * Some("ftp").collect({case "http" => "HTTP"}) + * + * // Returns None because None is passed to the collect method. + * None.collect({case value => value}) + * }}} + * * @param pf the partial function. * @return the result of applying `pf` to this $option's * value (if possible), or $none. From 14d1fe0c35f4ab07a0535adbdf8acbcbd1208363 Mon Sep 17 00:00:00 2001 From: Denys Shabalin Date: Wed, 2 Jul 2014 14:10:42 +0200 Subject: [PATCH 349/826] SI-8703 add support for blocks with just a single expression to quasiquotes Previously it was impossible to match a block that was constructed as Block(Nil, term) Due to the fact that quasiquotes always flatten those into just term. This is a correct behaviour for construction (for sake of consistency with parser) but doing it in deconstruction mode make it impossible to match such blocks which could have been constructed manually somewhere. To fix this we just disable block flattening in deconstruction mode. Interestingly enough this doesn't break existing code due to the fact that quasiquote's block matcher also matches expressions as single-element blocks. This allows to match single-element blocks with patterns like q"{ $foo }". --- .../scala/tools/reflect/quasiquotes/Parsers.scala | 11 ++++++++--- src/reflect/scala/reflect/internal/TreeGen.scala | 4 ++-- .../quasiquotes/TermDeconstructionProps.scala | 7 +++++++ 3 files changed, 17 insertions(+), 5 deletions(-) diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala b/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala index b68022afd971..460d02c2182e 100644 --- a/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala +++ b/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala @@ -69,9 +69,14 @@ trait Parsers { self: Quasiquotes => override def makeTupleType(trees: List[Tree]): Tree = TupleTypePlaceholder(trees) // q"{ $x }" - override def makeBlock(stats: List[Tree]): Tree = stats match { - case (head @ Ident(name)) :: Nil if isHole(name) => Block(Nil, head) - case _ => super.makeBlock(stats) + override def makeBlock(stats: List[Tree]): Tree = method match { + case nme.apply => + stats match { + case (head @ Ident(name)) :: Nil if isHole(name) => Block(Nil, head) + case _ => super.makeBlock(stats) + } + case nme.unapply => gen.mkBlock(stats, doFlatten = false) + case other => global.abort("unreachable") } // tq"$a => $b" diff --git a/src/reflect/scala/reflect/internal/TreeGen.scala b/src/reflect/scala/reflect/internal/TreeGen.scala index 9066c73393d0..6e8e992d1656 100644 --- a/src/reflect/scala/reflect/internal/TreeGen.scala +++ b/src/reflect/scala/reflect/internal/TreeGen.scala @@ -451,10 +451,10 @@ abstract class TreeGen { def mkSyntheticUnit() = Literal(Constant(())).updateAttachment(SyntheticUnitAttachment) /** Create block of statements `stats` */ - def mkBlock(stats: List[Tree]): Tree = + def mkBlock(stats: List[Tree], doFlatten: Boolean = true): Tree = if (stats.isEmpty) mkSyntheticUnit() else if (!stats.last.isTerm) Block(stats, mkSyntheticUnit()) - else if (stats.length == 1) stats.head + else if (stats.length == 1 && doFlatten) stats.head else Block(stats.init, stats.last) /** Create a block that wraps multiple statements but don't diff --git a/test/files/scalacheck/quasiquotes/TermDeconstructionProps.scala b/test/files/scalacheck/quasiquotes/TermDeconstructionProps.scala index 49ffaff6308c..07e8f3faacd2 100644 --- a/test/files/scalacheck/quasiquotes/TermDeconstructionProps.scala +++ b/test/files/scalacheck/quasiquotes/TermDeconstructionProps.scala @@ -246,4 +246,11 @@ object TermDeconstructionProps extends QuasiquoteProperties("term deconstruction assert(f ≈ `new`) assert(argss.isEmpty) } + + property("SI-8703 extract block with single expression") = test { + val q"{ $a }" = Block(Nil, q"1") + val Literal(Constant(1)) = a + val q"{ $b }" = q"2" + val Literal(Constant(2)) = b + } } From 0c5dd9e02f03143372237018c55e12a07c13f8c1 Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Tue, 30 Apr 2013 21:14:06 +0200 Subject: [PATCH 350/826] [backport] SI-7470 implements fundep materialization Backports 21a8c6c from the 2.11.x branch under -Xfundep-materialization as per Miles Sabin's request. Thanks Miles! --- .../tools/nsc/settings/ScalaSettings.scala | 1 + .../scala/tools/nsc/typechecker/Macros.scala | 32 ++++++++++-- test/files/neg/t5923c.check | 4 ++ test/files/neg/t5923c/Macros_1.scala | 39 ++++++++++++++ test/files/neg/t5923c/Test_2.scala | 12 +++++ .../run/{t5923a.check => t5923a-fundep.check} | 0 test/files/run/t5923a-fundep.flags | 1 + test/files/run/t5923a-fundep/Macros_1.scala | 52 +++++++++++++++++++ .../{t5923a => t5923a-fundep}/Test_2.scala | 0 test/files/run/t5923a-nofundep.check | 3 ++ .../Macros_1.scala | 0 test/files/run/t5923a-nofundep/Test_2.scala | 5 ++ test/files/run/t5923c.check | 1 + test/files/run/t5923c.flags | 1 + test/files/run/t5923c/Macros_1.scala | 39 ++++++++++++++ test/files/run/t5923c/Test_2.scala | 12 +++++ test/files/run/t5923d.check | 0 test/files/run/t5923d/Macros_1.scala | 9 ++++ test/files/run/t5923d/Test_2.scala | 7 +++ 19 files changed, 214 insertions(+), 4 deletions(-) create mode 100644 test/files/neg/t5923c.check create mode 100644 test/files/neg/t5923c/Macros_1.scala create mode 100644 test/files/neg/t5923c/Test_2.scala rename test/files/run/{t5923a.check => t5923a-fundep.check} (100%) create mode 100644 test/files/run/t5923a-fundep.flags create mode 100644 test/files/run/t5923a-fundep/Macros_1.scala rename test/files/run/{t5923a => t5923a-fundep}/Test_2.scala (100%) create mode 100644 test/files/run/t5923a-nofundep.check rename test/files/run/{t5923a => t5923a-nofundep}/Macros_1.scala (100%) create mode 100644 test/files/run/t5923a-nofundep/Test_2.scala create mode 100644 test/files/run/t5923c.check create mode 100644 test/files/run/t5923c.flags create mode 100644 test/files/run/t5923c/Macros_1.scala create mode 100644 test/files/run/t5923c/Test_2.scala create mode 100644 test/files/run/t5923d.check create mode 100644 test/files/run/t5923d/Macros_1.scala create mode 100644 test/files/run/t5923d/Test_2.scala diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala index dbfaa2c53112..3a6d183c324e 100644 --- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala @@ -111,6 +111,7 @@ trait ScalaSettings extends AbsScalaSettings val XnoPatmatAnalysis = BooleanSetting ("-Xno-patmat-analysis", "Don't perform exhaustivity/unreachability analysis. Also, ignore @switch annotation.") val XfullLubs = BooleanSetting ("-Xfull-lubs", "Retains pre 2.10 behavior of less aggressive truncation of least upper bounds.") val Xdivergence211 = BooleanSetting ("-Xdivergence211", "Turn on the 2.11 behavior of implicit divergence not terminating recursive implicit searches (SI-7291).") + val XfundepMaterialization = BooleanSetting("-Xfundep-materialization", "Turn on the 2.11 behavior of macro expansion being able to influence type inference in implicit searches") /** Compatibility stubs for options whose value name did * not previously match the option name. diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala index d6ec5f2cb0a0..6801dc068c16 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala @@ -713,6 +713,13 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces { var expectedTpe = expandee.tpe if (isNullaryInvocation(expandee)) expectedTpe = expectedTpe.finalResultType + if (settings.XfundepMaterialization.value) { + // approximation is necessary for whitebox macros to guide type inference + // read more in the comments for onDelayed below + val undetparams = expectedTpe collect { case tp if tp.typeSymbol.isTypeParameter => tp.typeSymbol } + expectedTpe = deriveTypeWithWildcards(undetparams)(expectedTpe) + } + // also see http://groups.google.com/group/scala-internals/browse_thread/thread/492560d941b315cc val expanded0 = duplicateAndKeepPositions(expanded) val expanded1 = typecheck("macro def return type", expanded0, expectedTpe) @@ -766,9 +773,24 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces { // (in a sense that a datatype's uniform representation is unambiguously determined by the datatype, // e.g. for Foo it will be Int :: String :: Boolean :: HNil), there's no way to convey this information // to the typechecker. Therefore the typechecker will infer Nothing for L, which is hardly what we want. + // + // =========== THE SOLUTION =========== + // + // To give materializers a chance to say their word before vanilla inference kicks in, + // we infer as much as possible (e.g. in the example above even though L is hopeless, C still can be inferred to Foo) + // and then trigger macro expansion with the undetermined type parameters still there. + // Thanks to that the materializer can take a look at what's going on and react accordingly. + // + // NOTE: This functionality is only available under the -Xfundep-materialization flag in Scala 2.10, + // but is enabled by default in Scala 2.11. val shouldInstantiate = typer.context.undetparams.nonEmpty && !inPolyMode(mode) - if (shouldInstantiate) typer.instantiatePossiblyExpectingUnit(delayed, mode, pt) - else delayed + if (shouldInstantiate) { + if (settings.XfundepMaterialization.value) { + forced += delayed + typer.infer.inferExprInstance(delayed, typer.context.extractUndetparams(), pt, keepNothings = false) + macroExpand(typer, delayed, mode, pt) + } else typer.instantiatePossiblyExpectingUnit(delayed, mode, pt) + } else delayed case Fallback(fallback) => typer.context.withImplicitsEnabled(typer.typed(fallback, EXPRmode, pt)) case Other(result) => @@ -886,10 +908,12 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces { * 2) undetparams (sym.isTypeParameter && !sym.isSkolem) */ var hasPendingMacroExpansions = false + private val forced = perRunCaches.newWeakSet[Tree] private val delayed = perRunCaches.newWeakMap[Tree, scala.collection.mutable.Set[Int]] private def isDelayed(expandee: Tree) = delayed contains expandee private def calculateUndetparams(expandee: Tree): scala.collection.mutable.Set[Int] = - delayed.get(expandee).getOrElse { + if (forced(expandee)) scala.collection.mutable.Set[Int]() + else delayed.getOrElse(expandee, { val calculated = scala.collection.mutable.Set[Symbol]() expandee foreach (sub => { def traverse(sym: Symbol) = if (sym != null && (undetparams contains sym.id)) calculated += sym @@ -898,7 +922,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces { }) macroLogVerbose("calculateUndetparams: %s".format(calculated)) calculated map (_.id) - } + }) private val undetparams = perRunCaches.newSet[Int] def notifyUndetparamsAdded(newUndets: List[Symbol]): Unit = { undetparams ++= newUndets map (_.id) diff --git a/test/files/neg/t5923c.check b/test/files/neg/t5923c.check new file mode 100644 index 000000000000..6d3d6b1b78bb --- /dev/null +++ b/test/files/neg/t5923c.check @@ -0,0 +1,4 @@ +Test_2.scala:7: error: could not find implicit value for parameter iso: Iso[Test.Foo,L] + val equiv = foo(Foo(23, "foo", true)) + ^ +one error found diff --git a/test/files/neg/t5923c/Macros_1.scala b/test/files/neg/t5923c/Macros_1.scala new file mode 100644 index 000000000000..0b7a3399e205 --- /dev/null +++ b/test/files/neg/t5923c/Macros_1.scala @@ -0,0 +1,39 @@ +import language.experimental.macros +import scala.reflect.macros.Context + +trait Iso[T, U] { + def to(t : T) : U + // def from(u : U) : T +} + +object Iso { + implicit def materializeIso[T, U]: Iso[T, U] = macro impl[T, U] + def impl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: Context): c.Expr[Iso[T, U]] = { + import c.universe._ + import definitions._ + import Flag._ + + val sym = c.weakTypeOf[T].typeSymbol + if (!sym.isClass || !sym.asClass.isCaseClass) c.abort(c.enclosingPosition, s"$sym is not a case class") + val fields = sym.typeSignature.declarations.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } + + def mkTpt() = { + val core = Ident(TupleClass(fields.length) orElse UnitClass) + if (fields.length == 0) core + else AppliedTypeTree(core, fields map (f => TypeTree(f.typeSignature))) + } + + def mkFrom() = { + if (fields.length == 0) Literal(Constant(Unit)) + else Apply(Ident(newTermName("Tuple" + fields.length)), fields map (f => Select(Ident(newTermName("f")), newTermName(f.name.toString.trim)))) + } + + val evidenceClass = ClassDef(Modifiers(FINAL), newTypeName("$anon"), List(), Template( + List(AppliedTypeTree(Ident(newTypeName("Iso")), List(Ident(sym), mkTpt()))), + emptyValDef, + List( + DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(())))), + DefDef(Modifiers(), newTermName("to"), List(), List(List(ValDef(Modifiers(PARAM), newTermName("f"), Ident(sym), EmptyTree))), TypeTree(), mkFrom())))) + c.Expr[Iso[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), nme.CONSTRUCTOR), List()))) + } +} diff --git a/test/files/neg/t5923c/Test_2.scala b/test/files/neg/t5923c/Test_2.scala new file mode 100644 index 000000000000..a00f4ed7dbf4 --- /dev/null +++ b/test/files/neg/t5923c/Test_2.scala @@ -0,0 +1,12 @@ +// see the comments for macroExpandApply.onDelayed for an explanation of what's tested here +object Test extends App { + case class Foo(i: Int, s: String, b: Boolean) + def foo[C, L](c: C)(implicit iso: Iso[C, L]): L = iso.to(c) + + { + val equiv = foo(Foo(23, "foo", true)) + def typed[T](t: => T) {} + typed[(Int, String, Boolean)](equiv) + println(equiv) + } +} \ No newline at end of file diff --git a/test/files/run/t5923a.check b/test/files/run/t5923a-fundep.check similarity index 100% rename from test/files/run/t5923a.check rename to test/files/run/t5923a-fundep.check diff --git a/test/files/run/t5923a-fundep.flags b/test/files/run/t5923a-fundep.flags new file mode 100644 index 000000000000..c8b4511960d0 --- /dev/null +++ b/test/files/run/t5923a-fundep.flags @@ -0,0 +1 @@ +-Xfundep-materialization \ No newline at end of file diff --git a/test/files/run/t5923a-fundep/Macros_1.scala b/test/files/run/t5923a-fundep/Macros_1.scala new file mode 100644 index 000000000000..97076eb1029f --- /dev/null +++ b/test/files/run/t5923a-fundep/Macros_1.scala @@ -0,0 +1,52 @@ +import scala.reflect.macros.Context +import language.experimental.macros + +case class C[T](t: String) +object C { + implicit def foo[T]: C[T] = macro Macros.impl[T] +} + +object Macros { + def impl[T](c: Context)(ttag: c.WeakTypeTag[T]) = { + import c.universe._ + val ttag0 = ttag; + { + // When we're expanding implicitly[C[Nothing]], the type inferencer will see + // that foo[T] returns C[T] and that we request an implicit of type C[Nothing]. + // + // Then the type inferencer will try to match C[T] against C[Nothing] and infer everything it can infer + // from that match, but not more (e.g. if we were returning Iso[T, U] and the type we were looking at was Iso[Foo, L], + // we wouldn't want U to be auto-inferred to Nothing, as it usually happens with normal methods, + // but would rather want it to remain unknown, so that our macro could take a stab at inferring it: + // see the comments in this commit for more information). + // + // Equipped with common sense, in our case of C[T] and C[Nothing] we would expect T to be inferred as Nothing, and then we + // would expect T in the corresponding macro invocation to be Nothing. Unfortunately it is not that simple. + // + // Internally the type inferencer uses Nothing as a dummy value, which stands for "don't know how to + // infer this type parameter". In the Iso example, matching Iso[T, U] against Iso[Foo, L] would result in + // T being inferred as Foo and U being inferred as Nothing (!!). Then the type inferencer will think: + // "Aha! U ended up being Nothing. This means that I failed to infer it, + // therefore the result of my work is: T -> Foo, U -> still unknown". + // + // That's all very good and works very well until Nothing is a genuine result of type inference, + // as in our original example of inferring T in C[T] from C[Nothing]. In that case, the inferencer becomes confused + // and here in the macro implementation we get weakTypeOf[T] equal to some dummy type carrying a type parameter + // instead of Nothing. + // + // This eccentric behavior of the type inferencer is a long-standing problem in scalac, + // so the best one can do for now until it's fixed is to work around, manually converting + // suspicious T's into Nothings. Of course, this means that we would have to approximate, + // because there's no way to know whether having T here stands for a failed attempt to infer Nothing + // or for a failed attempt to infer anything, but at least we're in full control of making the best + // of this sad situation. + implicit def ttag: WeakTypeTag[T] = { + val tpe = ttag0.tpe + val sym = tpe.typeSymbol.asType + if (sym.isParameter && !sym.isSkolem) TypeTag.Nothing.asInstanceOf[TypeTag[T]] + else ttag0 + } + reify(C[T](c.literal(weakTypeOf[T].toString).splice)) + } + } +} \ No newline at end of file diff --git a/test/files/run/t5923a/Test_2.scala b/test/files/run/t5923a-fundep/Test_2.scala similarity index 100% rename from test/files/run/t5923a/Test_2.scala rename to test/files/run/t5923a-fundep/Test_2.scala diff --git a/test/files/run/t5923a-nofundep.check b/test/files/run/t5923a-nofundep.check new file mode 100644 index 000000000000..7165b734acb9 --- /dev/null +++ b/test/files/run/t5923a-nofundep.check @@ -0,0 +1,3 @@ +C(Int) +C(String) +C(Nothing) diff --git a/test/files/run/t5923a/Macros_1.scala b/test/files/run/t5923a-nofundep/Macros_1.scala similarity index 100% rename from test/files/run/t5923a/Macros_1.scala rename to test/files/run/t5923a-nofundep/Macros_1.scala diff --git a/test/files/run/t5923a-nofundep/Test_2.scala b/test/files/run/t5923a-nofundep/Test_2.scala new file mode 100644 index 000000000000..001ff9aea8f4 --- /dev/null +++ b/test/files/run/t5923a-nofundep/Test_2.scala @@ -0,0 +1,5 @@ +object Test extends App { + println(implicitly[C[Int]]) + println(implicitly[C[String]]) + println(implicitly[C[Nothing]]) +} \ No newline at end of file diff --git a/test/files/run/t5923c.check b/test/files/run/t5923c.check new file mode 100644 index 000000000000..bed7429108cc --- /dev/null +++ b/test/files/run/t5923c.check @@ -0,0 +1 @@ +(23,foo,true) diff --git a/test/files/run/t5923c.flags b/test/files/run/t5923c.flags new file mode 100644 index 000000000000..c8b4511960d0 --- /dev/null +++ b/test/files/run/t5923c.flags @@ -0,0 +1 @@ +-Xfundep-materialization \ No newline at end of file diff --git a/test/files/run/t5923c/Macros_1.scala b/test/files/run/t5923c/Macros_1.scala new file mode 100644 index 000000000000..0b7a3399e205 --- /dev/null +++ b/test/files/run/t5923c/Macros_1.scala @@ -0,0 +1,39 @@ +import language.experimental.macros +import scala.reflect.macros.Context + +trait Iso[T, U] { + def to(t : T) : U + // def from(u : U) : T +} + +object Iso { + implicit def materializeIso[T, U]: Iso[T, U] = macro impl[T, U] + def impl[T: c.WeakTypeTag, U: c.WeakTypeTag](c: Context): c.Expr[Iso[T, U]] = { + import c.universe._ + import definitions._ + import Flag._ + + val sym = c.weakTypeOf[T].typeSymbol + if (!sym.isClass || !sym.asClass.isCaseClass) c.abort(c.enclosingPosition, s"$sym is not a case class") + val fields = sym.typeSignature.declarations.toList.collect{ case x: TermSymbol if x.isVal && x.isCaseAccessor => x } + + def mkTpt() = { + val core = Ident(TupleClass(fields.length) orElse UnitClass) + if (fields.length == 0) core + else AppliedTypeTree(core, fields map (f => TypeTree(f.typeSignature))) + } + + def mkFrom() = { + if (fields.length == 0) Literal(Constant(Unit)) + else Apply(Ident(newTermName("Tuple" + fields.length)), fields map (f => Select(Ident(newTermName("f")), newTermName(f.name.toString.trim)))) + } + + val evidenceClass = ClassDef(Modifiers(FINAL), newTypeName("$anon"), List(), Template( + List(AppliedTypeTree(Ident(newTypeName("Iso")), List(Ident(sym), mkTpt()))), + emptyValDef, + List( + DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(())))), + DefDef(Modifiers(), newTermName("to"), List(), List(List(ValDef(Modifiers(PARAM), newTermName("f"), Ident(sym), EmptyTree))), TypeTree(), mkFrom())))) + c.Expr[Iso[T, U]](Block(List(evidenceClass), Apply(Select(New(Ident(newTypeName("$anon"))), nme.CONSTRUCTOR), List()))) + } +} diff --git a/test/files/run/t5923c/Test_2.scala b/test/files/run/t5923c/Test_2.scala new file mode 100644 index 000000000000..a00f4ed7dbf4 --- /dev/null +++ b/test/files/run/t5923c/Test_2.scala @@ -0,0 +1,12 @@ +// see the comments for macroExpandApply.onDelayed for an explanation of what's tested here +object Test extends App { + case class Foo(i: Int, s: String, b: Boolean) + def foo[C, L](c: C)(implicit iso: Iso[C, L]): L = iso.to(c) + + { + val equiv = foo(Foo(23, "foo", true)) + def typed[T](t: => T) {} + typed[(Int, String, Boolean)](equiv) + println(equiv) + } +} \ No newline at end of file diff --git a/test/files/run/t5923d.check b/test/files/run/t5923d.check new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/files/run/t5923d/Macros_1.scala b/test/files/run/t5923d/Macros_1.scala new file mode 100644 index 000000000000..f32d1af704a6 --- /dev/null +++ b/test/files/run/t5923d/Macros_1.scala @@ -0,0 +1,9 @@ +import scala.language.experimental.macros +import scala.reflect.macros.Context + +trait MappedRow +trait RowMapper[T <: MappedRow] +object RowMapper { + implicit def mapper[T <: MappedRow]: RowMapper[T] = macro impl[T] + def impl[T <: MappedRow : c.WeakTypeTag](c: Context) = c.universe.reify(new RowMapper[T]{}) +} \ No newline at end of file diff --git a/test/files/run/t5923d/Test_2.scala b/test/files/run/t5923d/Test_2.scala new file mode 100644 index 000000000000..6be10227c2f6 --- /dev/null +++ b/test/files/run/t5923d/Test_2.scala @@ -0,0 +1,7 @@ +class RowA extends MappedRow +class RowB extends MappedRow + +object Test extends App { + implicitly[RowMapper[RowA]] + implicitly[RowMapper[RowB]] +} \ No newline at end of file From b3c4e3ace9e68050f8e07af931a8f1b55cf90f7c Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Tue, 1 Jul 2014 13:45:41 +0200 Subject: [PATCH 351/826] Document SuperAccessors Added comment giving an up-to-date overview of SuperAccessors and how we might want to change it. --- .../nsc/typechecker/SuperAccessors.scala | 46 +++++++++++++++---- 1 file changed, 36 insertions(+), 10 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala index 9b9e641cada5..b6d37ab9a77a 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala @@ -12,21 +12,47 @@ import scala.collection.{ mutable, immutable } import mutable.ListBuffer import symtab.Flags._ -/** This phase adds super accessors for all super calls that either +/** This phase performs the following functions, each of which could be split out in a + * mini-phase: + * + * (1) Adds super accessors for all super calls that either * appear in a trait or have as a target a member of some outer class. - * It also replaces references to parameter accessors with aliases - * by super references to these aliases. The phase also checks that - * symbols accessed from super are not abstract, or are overridden by - * an abstract override. Finally, the phase also mangles the names - * of class-members which are private up to an enclosing non-package - * class, in order to avoid overriding conflicts. * - * This phase also sets SPECIALIZED flag on type parameters with + * (2) Converts references to parameter fields that have the same name as a corresponding + * public parameter field in a superclass to a reference to the superclass + * field (corresponding = super class field is initialized with subclass field). + * This info is pre-computed by the `alias` field in Typer. `dotc` follows a different + * route; it computes everything in SuperAccessors and changes the subclass field + * to a forwarder instead of manipulating references. This is more modular. + * + * (3) Adds protected accessors if the access to the protected member happens + * in a class which is not a subclass of the member's owner. + * + * (4) Mangles the names of class-members which are + * private up to an enclosing non-package class, in order to avoid overriding conflicts. + * This is a dubious, and it would be better to deprecate class-qualified privates. + * + * (5) This phase also sets SPECIALIZED flag on type parameters with * `@specialized` annotation. We put this logic here because the * flag must be set before pickling. * - * @author Martin Odersky - * @version 1.0 + * It also checks that: + * + * (1) Symbols accessed from super are not abstract, or are overridden by + * an abstract override. + * + * (2) If a symbol accessed accessed from super is defined in a real class (not a trait), + * there are no abstract members which override this member in Java's rules + * (see SI-4989; such an access would lead to illegal bytecode) + * + * (3) Super calls do not go to some synthetic members of Any (see isDisallowed) + * + * (4) Super calls do not go to synthetic field accessors + * + * (5) A class and its companion object do not both define a class or module with the + * same name. + * + * TODO: Rename phase to "Accessors" because it handles more than just super accessors */ abstract class SuperAccessors extends transform.Transform with transform.TypingTransformers { import global._ From 1e2a21681a4a55469faa59b07473a3b269e70258 Mon Sep 17 00:00:00 2001 From: jxcoder Date: Thu, 3 Jul 2014 17:16:58 +0700 Subject: [PATCH 352/826] SI-8705 Added example to Option.contains method. --- src/library/scala/Option.scala | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/library/scala/Option.scala b/src/library/scala/Option.scala index 5a1c832faead..9371775d6728 100644 --- a/src/library/scala/Option.scala +++ b/src/library/scala/Option.scala @@ -210,6 +210,17 @@ sealed abstract class Option[+A] extends Product with Serializable { } /** Tests whether the option contains a given value as an element. + * + * @example {{{ + * // Returns true because Some instance contains string "something" which equals "something". + * Some("something") contains "something" + * + * // Returns false because "something" != "anything". + * Some("something") contains "anything" + * + * // Returns false when method called on None. + * None contains "anything" + * }}} * * @param elem the element to test. * @return `true` if the option has an element that is equal (as From 364c8e9fde9212d9c7cf543ffe73206b2b00c67d Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Thu, 3 Jul 2014 13:16:08 +0200 Subject: [PATCH 353/826] pull request feedback --- src/compiler/scala/tools/nsc/typechecker/Macros.scala | 1 + 1 file changed, 1 insertion(+) diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala index 6801dc068c16..f0770e84c4a4 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala @@ -912,6 +912,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces { private val delayed = perRunCaches.newWeakMap[Tree, scala.collection.mutable.Set[Int]] private def isDelayed(expandee: Tree) = delayed contains expandee private def calculateUndetparams(expandee: Tree): scala.collection.mutable.Set[Int] = + // !settings.XfundepMaterialization.value implies forced.isEmpty if (forced(expandee)) scala.collection.mutable.Set[Int]() else delayed.getOrElse(expandee, { val calculated = scala.collection.mutable.Set[Symbol]() From 36379cf8af8e0bb92f7a399fe2c8e1cb05b31fc9 Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Thu, 3 Jul 2014 17:02:34 +0200 Subject: [PATCH 354/826] [backport] transformers no longer ignore UnApply.fun Backports 7122560063 and 4133eb8454 from the 2.11.x branch --- .../scala/tools/reflect/ToolBoxFactory.scala | 104 +++++++++++------- .../scala/reflect/internal/Trees.scala | 2 +- test/files/run/t7871.check | 1 + test/files/run/t7871/Macros_1.scala | 43 ++++++++ test/files/run/t7871/Test_2.scala | 6 + 5 files changed, 114 insertions(+), 42 deletions(-) create mode 100644 test/files/run/t7871.check create mode 100644 test/files/run/t7871/Macros_1.scala create mode 100644 test/files/run/t7871/Test_2.scala diff --git a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala index 387748dcdf3a..650598f9dba5 100644 --- a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala +++ b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala @@ -5,9 +5,10 @@ import scala.tools.nsc.reporters._ import scala.tools.nsc.CompilerCommand import scala.tools.nsc.Global import scala.tools.nsc.typechecker.Modes -import scala.tools.nsc.io.VirtualDirectory +import scala.tools.nsc.io.{AbstractFile, VirtualDirectory} import scala.tools.nsc.interpreter.AbstractFileClassLoader import scala.tools.nsc.util.FreshNameCreator +import scala.tools.nsc.util.CommandLineParser import scala.tools.nsc.ast.parser.Tokens.EOF import scala.reflect.internal.Flags._ import scala.reflect.internal.util.{BatchSourceFile, NoSourceFile, NoFile} @@ -17,6 +18,7 @@ import scala.reflect.NameTransformer import scala.reflect.api.JavaUniverse import scala.reflect.io.NoAbstractFile import scala.tools.nsc.interactive.RangePositions +import scala.reflect.internal.FatalError abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf => @@ -32,6 +34,13 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf => lazy val classLoader = new AbstractFileClassLoader(virtualDirectory, factorySelf.mirror.classLoader) lazy val mirror: u.Mirror = u.runtimeMirror(classLoader) + lazy val arguments = CommandLineParser.tokenize(options) + lazy val virtualDirectory = + arguments.iterator.sliding(2).collectFirst{ case Seq("-d", dir) => dir } match { + case Some(outDir) => AbstractFile.getDirectory(outDir) + case None => new VirtualDirectory("(memory)", None) + } + class ToolBoxGlobal(settings: scala.tools.nsc.Settings, reporter: Reporter) extends ReflectGlobal(settings, reporter, toolBoxSelf.classLoader) { import definitions._ @@ -50,7 +59,6 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf => } // should be called after every use of ToolBoxGlobal in order to prevent leaks - // there's the `withCleanupCaches` method defined below, which provides a convenient interface for that def cleanupCaches(): Unit = { perRunCaches.clearAll() undoLog.clear() @@ -59,10 +67,6 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf => lastSeenContext = null } - def withCleanupCaches[T](body: => T): T = - try body - finally cleanupCaches() - def verify(expr: Tree): Tree = { // Previously toolboxes used to typecheck their inputs before compiling. // Actually, the initial demo by Martin first typechecked the reified tree, @@ -312,42 +316,51 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf => } } - // todo. is not going to work with quoted arguments with embedded whitespaces - lazy val arguments = options.split(" ") + trait CompilerApi { + val compiler: ToolBoxGlobal + val importer: compiler.Importer { val from: u.type } + val exporter: u.Importer { val from: compiler.type } + } - lazy val virtualDirectory = - (arguments zip arguments.tail).collect{ case ("-d", dir) => dir }.lastOption match { - case Some(outDir) => scala.tools.nsc.io.AbstractFile.getDirectory(outDir) - case None => new VirtualDirectory("(memory)", None) + object withCompilerApi { + private object api extends CompilerApi { + lazy val compiler: ToolBoxGlobal = { + try { + val errorFn: String => Unit = msg => frontEnd.log(scala.reflect.internal.util.NoPosition, msg, frontEnd.ERROR) + val command = new CompilerCommand(arguments.toList, errorFn) + val settings = command.settings + settings.outputDirs setSingleOutput virtualDirectory + val reporter = frontEndToReporter(frontEnd, command.settings) + val instance = + if (settings.Yrangepos.value) new ToolBoxGlobal(settings, reporter) with RangePositions + else new ToolBoxGlobal(settings, reporter) + if (frontEnd.hasErrors) { + var msg = "reflective compilation has failed: cannot initialize the compiler: " + EOL + EOL + msg += frontEnd.infos map (_.msg) mkString EOL + throw ToolBoxError(msg) + } + instance + } catch { + case ex: Throwable => + var msg = "reflective compilation has failed: cannot initialize the compiler due to %s".format(ex.toString) + throw ToolBoxError(msg, ex) + } + } + + lazy val importer = compiler.mkImporter(u) + lazy val exporter = importer.reverse } - lazy val compiler: ToolBoxGlobal = { - try { - val errorFn: String => Unit = msg => frontEnd.log(scala.reflect.internal.util.NoPosition, msg, frontEnd.ERROR) - val command = new CompilerCommand(arguments.toList, errorFn) - val settings = command.settings - settings.outputDirs setSingleOutput virtualDirectory - val reporter = frontEndToReporter(frontEnd, command.settings) - val instance = - if (settings.Yrangepos.value) new ToolBoxGlobal(settings, reporter) with RangePositions - else new ToolBoxGlobal(settings, reporter) - if (frontEnd.hasErrors) { - var msg = "reflective compilation has failed: cannot initialize the compiler: " + EOL + EOL - msg += frontEnd.infos map (_.msg) mkString EOL - throw ToolBoxError(msg) - } - instance - } catch { - case ex: Throwable => - var msg = "reflective compilation has failed: cannot initialize the compiler due to %s".format(ex.toString) - throw ToolBoxError(msg, ex) + def apply[T](f: CompilerApi => T): T = { + object FatalError { def unapply(ex: Throwable) = ex match { case _: FatalError | _: AssertionError => Some(ex); case _ => None } } + try f(api) catch { case FatalError(ex) => throw ToolBoxError(s"fatal compiler error", ex) } + finally api.compiler.cleanupCaches() } } - lazy val importer = compiler.mkImporter(u) - lazy val exporter = importer.reverse + def typeCheck(tree: u.Tree, expectedType: u.Type, silent: Boolean = false, withImplicitViewsDisabled: Boolean = false, withMacrosDisabled: Boolean = false): u.Tree = withCompilerApi { compilerApi => + import compilerApi._ - def typeCheck(tree: u.Tree, expectedType: u.Type, silent: Boolean = false, withImplicitViewsDisabled: Boolean = false, withMacrosDisabled: Boolean = false): u.Tree = compiler.withCleanupCaches { if (compiler.settings.verbose.value) println("importing "+tree+", expectedType = "+expectedType) var ctree: compiler.Tree = importer.importTree(tree) var cexpectedType: compiler.Type = importer.importType(expectedType) @@ -367,7 +380,9 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf => inferImplicit(tree, viewTpe, isView = true, silent = silent, withMacrosDisabled = withMacrosDisabled, pos = pos) } - private def inferImplicit(tree: u.Tree, pt: u.Type, isView: Boolean, silent: Boolean, withMacrosDisabled: Boolean, pos: u.Position): u.Tree = compiler.withCleanupCaches { + private def inferImplicit(tree: u.Tree, pt: u.Type, isView: Boolean, silent: Boolean, withMacrosDisabled: Boolean, pos: u.Position): u.Tree = withCompilerApi { compilerApi => + import compilerApi._ + if (compiler.settings.verbose.value) println("importing "+pt, ", tree = "+tree+", pos = "+pos) var ctree: compiler.Tree = importer.importTree(tree) var cpt: compiler.Type = importer.importType(pt) @@ -379,31 +394,38 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf => uitree } - def resetAllAttrs(tree: u.Tree): u.Tree = { + def resetAllAttrs(tree: u.Tree): u.Tree = withCompilerApi { compilerApi => + import compilerApi._ val ctree: compiler.Tree = importer.importTree(tree) val ttree: compiler.Tree = compiler.resetAllAttrs(ctree) val uttree = exporter.importTree(ttree) uttree } - def resetLocalAttrs(tree: u.Tree): u.Tree = { + def resetLocalAttrs(tree: u.Tree): u.Tree = withCompilerApi { compilerApi => + import compilerApi._ val ctree: compiler.Tree = importer.importTree(tree) val ttree: compiler.Tree = compiler.resetLocalAttrs(ctree) val uttree = exporter.importTree(ttree) uttree } - def showAttributed(tree: u.Tree, printTypes: Boolean = true, printIds: Boolean = true, printKinds: Boolean = false): String = + def showAttributed(tree: u.Tree, printTypes: Boolean = true, printIds: Boolean = true, printKinds: Boolean = false): String = withCompilerApi { compilerApi => + import compilerApi._ compiler.showAttributed(importer.importTree(tree), printTypes, printIds, printKinds) + } - def parse(code: String): u.Tree = { + def parse(code: String): u.Tree = withCompilerApi { compilerApi => + import compilerApi._ if (compiler.settings.verbose.value) println("parsing "+code) val ctree: compiler.Tree = compiler.parse(code) val utree = exporter.importTree(ctree) utree } - def compile(tree: u.Tree): () => Any = { + def compile(tree: u.Tree): () => Any = withCompilerApi { compilerApi => + import compilerApi._ + if (compiler.settings.verbose.value) println("importing "+tree) val ctree: compiler.Tree = importer.importTree(tree) diff --git a/src/reflect/scala/reflect/internal/Trees.scala b/src/reflect/scala/reflect/internal/Trees.scala index 0e5985facef3..ab318bc624e4 100644 --- a/src/reflect/scala/reflect/internal/Trees.scala +++ b/src/reflect/scala/reflect/internal/Trees.scala @@ -1315,7 +1315,7 @@ trait Trees extends api.Trees { self: SymbolTable => case Star(elem) => treeCopy.Star(tree, transform(elem)) case UnApply(fun, args) => - treeCopy.UnApply(tree, fun, transformTrees(args)) // bq: see test/.../unapplyContexts2.scala + treeCopy.UnApply(tree, transform(fun), transformTrees(args)) // bq: see test/.../unapplyContexts2.scala case ArrayValue(elemtpt, trees) => treeCopy.ArrayValue(tree, transform(elemtpt), transformTrees(trees)) case ApplyDynamic(qual, args) => diff --git a/test/files/run/t7871.check b/test/files/run/t7871.check new file mode 100644 index 000000000000..ce6efd812d76 --- /dev/null +++ b/test/files/run/t7871.check @@ -0,0 +1 @@ +(SomeTree,SomeTree) diff --git a/test/files/run/t7871/Macros_1.scala b/test/files/run/t7871/Macros_1.scala new file mode 100644 index 000000000000..2943445ff832 --- /dev/null +++ b/test/files/run/t7871/Macros_1.scala @@ -0,0 +1,43 @@ +import scala.reflect.macros.Context +import scala.language.experimental.macros + +trait Tree +case object SomeTree extends Tree + +object NewQuasiquotes { + implicit class QuasiquoteInterpolation(c: StringContext) { + object nq { + def unapply(t: Tree): Any = macro QuasiquoteMacros.unapplyImpl + } + } +} + +object QuasiquoteMacros { + def unapplyImpl(c: Context)(t: c.Expr[Tree]) = { + import c.universe._ + import Flag._ + // q""" + // new { + // def unapply(t: Tree) = t match { + // case SomeTree => Some((SomeTree, SomeTree)) + // case _ => None + // } + // }.unapply($t) + // """ + c.Expr[Any](Apply( + Select( + Block(List( + ClassDef(Modifiers(FINAL), newTypeName("$anon"), List(), + Template(List(Select(Ident(newTermName("scala")), newTypeName("AnyRef"))), emptyValDef, List( + DefDef(Modifiers(), nme.CONSTRUCTOR, List(), List(List()), TypeTree(), + Block(List(Apply(Select(Super(This(tpnme.EMPTY), tpnme.EMPTY), nme.CONSTRUCTOR), List())), Literal(Constant(())))), + DefDef(Modifiers(), newTermName("unapply"), List(), List(List(ValDef(Modifiers(PARAM), newTermName("t"), Ident(newTypeName("Tree")), EmptyTree))), TypeTree(), + Match( + Ident(newTermName("t")), List( + CaseDef(Ident(newTermName("SomeTree")), EmptyTree, Apply(Ident(newTermName("Some")), List(Apply(Select(Ident(newTermName("scala")), newTermName("Tuple2")), List(Ident(newTermName("SomeTree")), Ident(newTermName("SomeTree"))))))), + CaseDef(Ident(nme.WILDCARD), EmptyTree, Ident(newTermName("None")))))))))), + Apply(Select(New(Ident(newTypeName("$anon"))), nme.CONSTRUCTOR), List())), + newTermName("unapply")), + List(t.tree))) + } +} diff --git a/test/files/run/t7871/Test_2.scala b/test/files/run/t7871/Test_2.scala new file mode 100644 index 000000000000..3a0b68b56851 --- /dev/null +++ b/test/files/run/t7871/Test_2.scala @@ -0,0 +1,6 @@ +object Test extends App { + import NewQuasiquotes._ + SomeTree match { + case nq"$x + $y" => println((x, y)) + } +} From acab0fa000e89d91ef6a809cd1cb70d519d29d5a Mon Sep 17 00:00:00 2001 From: "Paolo G. Giarrusso" Date: Tue, 24 Jun 2014 05:18:20 +0200 Subject: [PATCH 355/826] [backport] SI-8677 Duration: Zero - Inf should be MinusInf Fixes #8677. Add basic tests. This is a backport from 2.12.x of dead39dc5f21c6eac41788e93426c50ddd398c24. --- src/library/scala/concurrent/duration/Duration.scala | 2 +- test/files/jvm/duration-tck.scala | 5 +++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/src/library/scala/concurrent/duration/Duration.scala b/src/library/scala/concurrent/duration/Duration.scala index 1b50b7fa5672..2eded9f06090 100644 --- a/src/library/scala/concurrent/duration/Duration.scala +++ b/src/library/scala/concurrent/duration/Duration.scala @@ -621,7 +621,7 @@ final class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duratio } def -(other: Duration) = other match { case x: FiniteDuration => add(-x.length, x.unit) - case _ => other + case _ => -other } def *(factor: Double) = diff --git a/test/files/jvm/duration-tck.scala b/test/files/jvm/duration-tck.scala index 3bc8a2c1006d..7db6c49964e2 100644 --- a/test/files/jvm/duration-tck.scala +++ b/test/files/jvm/duration-tck.scala @@ -61,6 +61,11 @@ object Test extends App { minf - inf mustBe minf minf + minf mustBe minf + for (i <- Seq(zero, one, two, three)) { + i - inf mustBe minf + i - minf mustBe inf + } + inf.compareTo(inf) mustBe 0 inf.compareTo(one) mustBe 1 inf.compareTo(minf) mustBe 1 From ffb0e25fc8ec9d6ecb0cd806bc534e9430e37bd4 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 10 Jun 2014 15:59:23 +0200 Subject: [PATCH 356/826] Unclutter Reporter. Move truncation to ReplReporter. Refactor to reduce the Reporter interface. Working towards minimal interfaces in scala.reflect.internal that can be consumed by sbt/IDE/.... The scala.tools.nsc package is entirely private to the compiler (in principle). A `Reporter` should only be used to inform (info/warning/error). No state. Ideally, we'd move to having only one reporter, whose lifetime is adjusted appropriately (from per-run in general to per-context for type checking, so errors can be buffered -- "silenced" -- during nested type checking calls). Start the clean up by moving truncation to the REPL, since it's not relevant for regular reporting. Perversely, we were checking truncation all the time, even though it's only on during a repl run. (Truncation is now always turned off in the repl under -verbose.) Untangle error resetting on symbols from error reporting (reportAdditionalErrors). This fixes a nice&subtle bug that caused feature warnings to be suppressed under `-Xfatal-warnings`: ``` def reportCompileErrors() { if (!reporter.hasErrors && reporter.hasWarnings && settings.fatalWarnings) globalError("No warnings can be incurred under -Xfatal-warnings.") if (reporter.hasErrors) { ... } else { // will erroneously not get here if // `reporter.hasWarnings && settings.fatalWarnings` // since the `globalError` call above means `reporter.hasErrors`... allConditionalWarnings foreach (_.summarize()) ... } } ``` The second `if`'s condition depends on the `globalError` call in the first `if`... --- .../scala/tools/nsc/CompilationUnits.scala | 3 +- src/compiler/scala/tools/nsc/Global.scala | 58 ++++++++++--------- .../tools/nsc/reporters/ConsoleReporter.scala | 3 +- .../scala/tools/nsc/reporters/Reporter.scala | 37 +++++------- .../tools/nsc/reporters/StoreReporter.scala | 3 +- .../scala/tools/nsc/interpreter/IMain.scala | 4 +- .../tools/nsc/interpreter/ReplReporter.scala | 19 ++++++ test/files/neg/checksensible.check | 3 +- test/files/neg/overloaded-implicit.check | 3 +- test/files/neg/t6567.check | 3 +- test/files/neg/unchecked-refinement.check | 3 +- 11 files changed, 77 insertions(+), 62 deletions(-) diff --git a/src/compiler/scala/tools/nsc/CompilationUnits.scala b/src/compiler/scala/tools/nsc/CompilationUnits.scala index c2caed70a06e..924bb54ddbb5 100644 --- a/src/compiler/scala/tools/nsc/CompilationUnits.scala +++ b/src/compiler/scala/tools/nsc/CompilationUnits.scala @@ -146,7 +146,8 @@ trait CompilationUnits { global: Global => def incompleteInputError(pos: Position, msg:String) = reporter.incompleteInputError(pos, msg) - def comment(pos: Position, msg: String) = + // used by the IDE -- TODO: don't use reporter to communicate comments from parser to IDE! + def comment(pos: Position, msg: String): Unit = reporter.comment(pos, msg) /** Is this about a .java source file? */ diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index cb785de4b39e..836203e80df6 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -291,8 +291,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter) log(s"!!!$pos_s $msg") // such warnings always at least logged } - def informComplete(msg: String): Unit = reporter.withoutTruncating(inform(msg)) - def logError(msg: String, t: Throwable): Unit = () override def shouldLogAtThisPhase = settings.log.isSetByUser && ( @@ -351,9 +349,9 @@ class Global(var currentSettings: Settings, var reporter: Reporter) } if (settings.verbose || settings.Ylogcp) { - // Uses the "do not truncate" inform - informComplete("[search path for source files: " + classPath.sourcepaths.mkString(",") + "]") - informComplete("[search path for class files: " + classPath.asClasspathString + "]") + reporter.echo( + s"[search path for source files: ${classPath.sourcepaths.mkString(",")}]\n"+ + s"[search path for class files: ${classPath.asClasspathString}") } // The current division between scala.reflect.* and scala.tools.nsc.* is pretty @@ -1212,6 +1210,20 @@ class Global(var currentSettings: Settings, var reporter: Reporter) def uncheckedWarnings: List[(Position, String)] = uncheckedWarnings0.warnings.toList // used in sbt def deprecationWarnings: List[(Position, String)] = deprecationWarnings0.warnings.toList // used in sbt + def reportAdditionalErrors(): Unit = { + if (!reporter.hasErrors) { + if (reporter.hasWarnings && settings.fatalWarnings) + globalError("No warnings can be incurred under -Xfatal-warnings.") + + allConditionalWarnings foreach (_.summarize()) + + if (seenMacroExpansionsFallingBack) + warning("some macros could not be expanded and code fell back to overridden methods;"+ + "\nrecompiling with generated classfiles on the classpath might help.") + // todo: migrationWarnings + } + } + var reportedFeature = Set[Symbol]() /** Has any macro expansion used a fallback during this run? */ @@ -1416,6 +1428,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) refreshProgress() } + // for sbt def cancel() { reporter.cancelled = true } private def currentProgress = (phasec * size) + unitc @@ -1565,26 +1578,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter) } } - def reportCompileErrors() { - if (!reporter.hasErrors && reporter.hasWarnings && settings.fatalWarnings) - globalError("No warnings can be incurred under -Xfatal-warnings.") - - if (reporter.hasErrors) { - for ((sym, file) <- symSource.iterator) { - sym.reset(new loaders.SourcefileLoader(file)) - if (sym.isTerm) - sym.moduleClass reset loaders.moduleClassLoader - } - } - else { - allConditionalWarnings foreach (_.summarize()) - - if (seenMacroExpansionsFallingBack) - warning("some macros could not be expanded and code fell back to overridden methods;"+ - "\nrecompiling with generated classfiles on the classpath might help.") - // todo: migrationWarnings - } - } /** Caching member symbols that are def-s in Defintions because they might change from Run to Run. */ val runDefinitions: definitions.RunDefinitions = new definitions.RunDefinitions @@ -1597,7 +1590,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) def checkDeprecations() = { checkDeprecatedSettings(newCompilationUnit("")) - reportCompileErrors() + reportAdditionalErrors() } val units = sources map scripted map (new CompilationUnit(_)) @@ -1621,7 +1614,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) checkDeprecatedSettings(unitbuf.head) globalPhase = fromPhase - while (globalPhase.hasNext && !reporter.hasErrors) { + while (globalPhase.hasNext && !reporter.hasErrors) { val startTime = currentTime phase = globalPhase globalPhase.run() @@ -1667,6 +1660,8 @@ class Global(var currentSettings: Settings, var reporter: Reporter) advancePhase() } + reportAdditionalErrors() + if (traceSymbolActivity) units map (_.body) foreach (traceSymbols recordSymbolsInTree _) @@ -1674,8 +1669,15 @@ class Global(var currentSettings: Settings, var reporter: Reporter) if (settings.Yshow.isDefault) showMembers() - reportCompileErrors() + if (reporter.hasErrors) { + for ((sym, file) <- symSource.iterator) { + sym.reset(new loaders.SourcefileLoader(file)) + if (sym.isTerm) + sym.moduleClass reset loaders.moduleClassLoader + } + } symSource.keys foreach (x => resetPackageClass(x.owner)) + informTime("total", startTime) // Clear any sets or maps created via perRunCaches. diff --git a/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala b/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala index 3f210a543c10..0b218b711c82 100644 --- a/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala +++ b/src/compiler/scala/tools/nsc/reporters/ConsoleReporter.scala @@ -12,8 +12,7 @@ import scala.reflect.internal.util._ import StringOps._ /** - * This class implements a Reporter that displays messages on a text - * console. + * This class implements a Reporter that displays messages on a text console. */ class ConsoleReporter(val settings: Settings, reader: BufferedReader, writer: PrintWriter) extends AbstractReporter { def this(settings: Settings) = this(settings, Console.in, new PrintWriter(Console.err, true)) diff --git a/src/compiler/scala/tools/nsc/reporters/Reporter.scala b/src/compiler/scala/tools/nsc/reporters/Reporter.scala index 68362c066d80..766a35960bbb 100644 --- a/src/compiler/scala/tools/nsc/reporters/Reporter.scala +++ b/src/compiler/scala/tools/nsc/reporters/Reporter.scala @@ -8,9 +8,10 @@ package reporters import scala.reflect.internal.util._ -/** - * This interface provides methods to issue information, warning and - * error messages. +/** Report information, warnings and errors. + * + * This describes the stable interface for issuing information, warnings and errors. + * The only abstract method in this class must be info0. */ abstract class Reporter { protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit @@ -29,19 +30,6 @@ abstract class Reporter { override def toString: String = "ERROR" } - /** Whether very long lines can be truncated. This exists so important - * debugging information (like printing the classpath) is not rendered - * invisible due to the max message length. - */ - private var _truncationOK: Boolean = true - def truncationOK = _truncationOK - def withoutTruncating[T](body: => T): T = { - val saved = _truncationOK - _truncationOK = false - try body - finally _truncationOK = saved - } - private var incompleteHandler: (Position, String) => Unit = null def incompleteHandled = incompleteHandler != null def withIncompleteHandler[T](handler: (Position, String) => Unit)(thunk: => T) = { @@ -51,6 +39,7 @@ abstract class Reporter { finally incompleteHandler = saved } + // used by sbt (via unit.cancel) to cancel a compile (see hasErrors) var cancelled = false def hasErrors = ERROR.count > 0 || cancelled def hasWarnings = WARNING.count > 0 @@ -58,21 +47,23 @@ abstract class Reporter { /** For sending a message which should not be labeled as a warning/error, * but also shouldn't require -verbose to be visible. */ - def echo(msg: String): Unit = info(NoPosition, msg, force = true) - def echo(pos: Position, msg: String): Unit = info(pos, msg, force = true) + def echo(msg: String): Unit = info(NoPosition, msg, force = true) + def echo(pos: Position, msg: String): Unit = info(pos, msg, force = true) - /** Informational messages, suppressed unless -verbose or force=true. */ - def info(pos: Position, msg: String, force: Boolean): Unit = info0(pos, msg, INFO, force) + /** Informational messages. If `!force`, they may be suppressed. */ + final def info(pos: Position, msg: String, force: Boolean): Unit = info0(pos, msg, INFO, force) /** Warnings and errors. */ - def warning(pos: Position, msg: String): Unit = withoutTruncating(info0(pos, msg, WARNING, force = false)) - def error(pos: Position, msg: String): Unit = withoutTruncating(info0(pos, msg, ERROR, force = false)) + def warning(pos: Position, msg: String): Unit = info0(pos, msg, WARNING, force = false) + def error(pos: Position, msg: String): Unit = info0(pos, msg, ERROR, force = false) def incompleteInputError(pos: Position, msg: String): Unit = { if (incompleteHandled) incompleteHandler(pos, msg) else error(pos, msg) } - def comment(pos: Position, msg: String) { } + // overridden by sbt, IDE: + // `comment` is unrelated to reporting and should move out (IDE receives comments from ScaladocAnalyzer) + def comment(pos: Position, msg: String) {} def flush() { } def reset() { INFO.count = 0 diff --git a/src/compiler/scala/tools/nsc/reporters/StoreReporter.scala b/src/compiler/scala/tools/nsc/reporters/StoreReporter.scala index 04c5bdf82438..24a61cb17158 100644 --- a/src/compiler/scala/tools/nsc/reporters/StoreReporter.scala +++ b/src/compiler/scala/tools/nsc/reporters/StoreReporter.scala @@ -10,8 +10,7 @@ import scala.collection.mutable import scala.reflect.internal.util.Position /** - * This class implements a Reporter that displays messages on a text - * console. + * This class implements a Reporter that stores its reports in the set `infos`. */ class StoreReporter extends Reporter { case class Info(pos: Position, msg: String, severity: Severity) { diff --git a/src/repl/scala/tools/nsc/interpreter/IMain.scala b/src/repl/scala/tools/nsc/interpreter/IMain.scala index 47d97dd4ddfc..2deeed2be318 100644 --- a/src/repl/scala/tools/nsc/interpreter/IMain.scala +++ b/src/repl/scala/tools/nsc/interpreter/IMain.scala @@ -110,7 +110,7 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set lazy val reporter: ReplReporter = new ReplReporter(this) import formatting._ - import reporter.{ printMessage, withoutTruncating } + import reporter.{ printMessage, printUntruncatedMessage } // This exists mostly because using the reporter too early leads to deadlock. private def echo(msg: String) { Console println msg } @@ -609,7 +609,7 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set } else { // don't truncate stack traces - withoutTruncating(printMessage(result)) + printUntruncatedMessage(result) IR.Error } } diff --git a/src/repl/scala/tools/nsc/interpreter/ReplReporter.scala b/src/repl/scala/tools/nsc/interpreter/ReplReporter.scala index b20166d0703b..88372334d6db 100644 --- a/src/repl/scala/tools/nsc/interpreter/ReplReporter.scala +++ b/src/repl/scala/tools/nsc/interpreter/ReplReporter.scala @@ -9,11 +9,29 @@ package interpreter import reporters._ import IMain._ +import scala.reflect.internal.util.Position + /** Like ReplGlobal, a layer for ensuring extra functionality. */ class ReplReporter(intp: IMain) extends ConsoleReporter(intp.settings, Console.in, new ReplStrippingWriter(intp)) { def printUntruncatedMessage(msg: String) = withoutTruncating(printMessage(msg)) + /** Whether very long lines can be truncated. This exists so important + * debugging information (like printing the classpath) is not rendered + * invisible due to the max message length. + */ + private var _truncationOK: Boolean = !intp.settings.verbose + def truncationOK = _truncationOK + def withoutTruncating[T](body: => T): T = { + val saved = _truncationOK + _truncationOK = false + try body + finally _truncationOK = saved + } + + override def warning(pos: Position, msg: String): Unit = withoutTruncating(super.warning(pos, msg)) + override def error(pos: Position, msg: String): Unit = withoutTruncating(super.error(pos, msg)) + override def printMessage(msg: String) { // Avoiding deadlock if the compiler starts logging before // the lazy val is complete. @@ -31,4 +49,5 @@ class ReplReporter(intp: IMain) extends ConsoleReporter(intp.settings, Console.i if (intp.totalSilence) () else super.displayPrompt() } + } diff --git a/test/files/neg/checksensible.check b/test/files/neg/checksensible.check index e5f1a38d96b8..38cc5ec447ad 100644 --- a/test/files/neg/checksensible.check +++ b/test/files/neg/checksensible.check @@ -98,5 +98,6 @@ checksensible.scala:95: warning: comparing values of types Unit and Int using `! while ((c = in.read) != -1) ^ error: No warnings can be incurred under -Xfatal-warnings. +error: there were 3 deprecation warnings; re-run with -deprecation for details 33 warnings found -one error found +two errors found diff --git a/test/files/neg/overloaded-implicit.check b/test/files/neg/overloaded-implicit.check index ca0870705d49..d9594d126acb 100644 --- a/test/files/neg/overloaded-implicit.check +++ b/test/files/neg/overloaded-implicit.check @@ -5,5 +5,6 @@ overloaded-implicit.scala:3: warning: parameterized overloaded implicit methods implicit def imp1[T](x: Set[T]): Map[T, T] = Map() ^ error: No warnings can be incurred under -Xfatal-warnings. +error: there were 4 feature warnings; re-run with -feature for details two warnings found -one error found +two errors found diff --git a/test/files/neg/t6567.check b/test/files/neg/t6567.check index a733d75354cf..3243fde0cd19 100644 --- a/test/files/neg/t6567.check +++ b/test/files/neg/t6567.check @@ -5,5 +5,6 @@ t6567.scala:10: warning: Suspicious application of an implicit view (Test.this.a val b: Option[B] = Option(a) ^ error: No warnings can be incurred under -Xfatal-warnings. +error: there was one feature warning; re-run with -feature for details two warnings found -one error found +two errors found diff --git a/test/files/neg/unchecked-refinement.check b/test/files/neg/unchecked-refinement.check index e85a51f44dad..b49e47fcbb59 100644 --- a/test/files/neg/unchecked-refinement.check +++ b/test/files/neg/unchecked-refinement.check @@ -11,5 +11,6 @@ unchecked-refinement.scala:24: warning: a pattern match on a refinement type is /* nowarn - todo */ case x: AnyRef { def size: Int } if b => x.size // this could/should do a static conformance test and not warn ^ error: No warnings can be incurred under -Xfatal-warnings. +error: there was one feature warning; re-run with -feature for details four warnings found -one error found +two errors found From f2b76e80094219db1f72a7a56d02f21bab1fc9eb Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 10 Jun 2014 09:44:24 +0200 Subject: [PATCH 357/826] Pure refactor: reorder definitions --- .../scala/tools/nsc/reporters/Reporter.scala | 55 +++++++++++-------- 1 file changed, 32 insertions(+), 23 deletions(-) diff --git a/src/compiler/scala/tools/nsc/reporters/Reporter.scala b/src/compiler/scala/tools/nsc/reporters/Reporter.scala index 766a35960bbb..1a8794d21790 100644 --- a/src/compiler/scala/tools/nsc/reporters/Reporter.scala +++ b/src/compiler/scala/tools/nsc/reporters/Reporter.scala @@ -16,6 +16,29 @@ import scala.reflect.internal.util._ abstract class Reporter { protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit + /** Informational messages. If `!force`, they may be suppressed. */ + final def info(pos: Position, msg: String, force: Boolean): Unit = info0(pos, msg, INFO, force) + + /** For sending a message which should not be labeled as a warning/error, + * but also shouldn't require -verbose to be visible. + */ + def echo(msg: String): Unit = info(NoPosition, msg, force = true) + def echo(pos: Position, msg: String): Unit = info(pos, msg, force = true) + + /** Warnings and errors. */ + def warning(pos: Position, msg: String): Unit = info0(pos, msg, WARNING, force = false) + def error(pos: Position, msg: String): Unit = info0(pos, msg, ERROR, force = false) + + def flush(): Unit = { } + + // overridden by sbt, IDE + def reset(): Unit = { + INFO.count = 0 + WARNING.count = 0 + ERROR.count = 0 + cancelled = false + } + object severity extends Enumeration class Severity(val id: Int) extends severity.Value { var count: Int = 0 @@ -40,35 +63,21 @@ abstract class Reporter { } // used by sbt (via unit.cancel) to cancel a compile (see hasErrors) - var cancelled = false - def hasErrors = ERROR.count > 0 || cancelled - def hasWarnings = WARNING.count > 0 + var cancelled: Boolean = false - /** For sending a message which should not be labeled as a warning/error, - * but also shouldn't require -verbose to be visible. - */ - def echo(msg: String): Unit = info(NoPosition, msg, force = true) - def echo(pos: Position, msg: String): Unit = info(pos, msg, force = true) + // overridden by sbt + def hasErrors: Boolean = ERROR.count > 0 || cancelled - /** Informational messages. If `!force`, they may be suppressed. */ - final def info(pos: Position, msg: String, force: Boolean): Unit = info0(pos, msg, INFO, force) + // overridden by sbt + def hasWarnings: Boolean = WARNING.count > 0 - /** Warnings and errors. */ - def warning(pos: Position, msg: String): Unit = info0(pos, msg, WARNING, force = false) - def error(pos: Position, msg: String): Unit = info0(pos, msg, ERROR, force = false) + // TODO def incompleteInputError(pos: Position, msg: String): Unit = { if (incompleteHandled) incompleteHandler(pos, msg) else error(pos, msg) } - // overridden by sbt, IDE: - // `comment` is unrelated to reporting and should move out (IDE receives comments from ScaladocAnalyzer) - def comment(pos: Position, msg: String) {} - def flush() { } - def reset() { - INFO.count = 0 - ERROR.count = 0 - WARNING.count = 0 - cancelled = false - } + // overridden by sbt, IDE -- should move out of this interface + // it's unrelated to reporting (IDE receives comments from ScaladocAnalyzer) + def comment(pos: Position, msg: String): Unit = {} } From 98216be3f3e546fc320ab5182ac5c129707db1ce Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 10 Jun 2014 16:24:37 +0200 Subject: [PATCH 358/826] Move reporting logic into Reporting trait Move code from Global/SymbolTable to separate Reporting traits to start carving out an interface in scala.reflect.internal.Reporting, with internals in scala.tools.nsc. Reporting is mixed into the cake. It contains a nested class PerRunReporting. Should do the same for debugging/logging. The idea is that CompilationUnit and Global forward all reporting to Reporter. The Reporting trait contains these forwarders, and PerRunReporting, which accumulates warning state during a run. In the process, I slightly changed the behavior of `globalError` in reflect.internal.SymbolTable: it used to abort, weirdly. I assume that was dummy behavior to avoid introducing an abstract method. It's immediately overridden in Global, and I couldn't find any other subclasses, so I don't think the behavior in SymbolTable was ever observed. Provide necessary hooks for scala.reflect.macros.Parsers#parse. See scala/reflect/macros/contexts/Parsers.scala's parse method, which overrides the reporter to detect when parsing goes wrong. This should be refactored, but that goes beyond the scope of this PR. Don't pop empty macro context stack. (Ran into this while reworking -Xfatal-warnings logic.) Fix -Xfatal-warnings behavior (and check files): it wasn't meant to influence warning reporting, except for emitting one final error; if necessary to fail the compile (when warnings but no errors were reported). Warnings should stay warnings. This was refactored in fbbbb22946, but we soon seem to have relapsed. An hour of gitfu did not lead to where it went wrong. Must've been a merge. --- bincompat-forward.whitelist.conf | 8 + .../reflect/macros/contexts/Parsers.scala | 5 +- .../scala/tools/nsc/CompilationUnits.scala | 37 ++--- .../scala/tools/nsc/CompileServer.scala | 4 +- src/compiler/scala/tools/nsc/Global.scala | 150 ++++++------------ src/compiler/scala/tools/nsc/Reporting.scala | 132 +++++++++++++++ .../tools/nsc/ast/parser/SyntaxAnalyzer.scala | 2 +- .../scala/tools/nsc/reporters/Reporter.scala | 15 -- .../scala/tools/nsc/typechecker/Macros.scala | 4 +- .../scala/tools/nsc/typechecker/Typers.scala | 16 +- .../scala/reflect/internal/Positions.scala | 11 +- .../scala/reflect/internal/Reporting.scala | 32 ++++ .../scala/reflect/internal/SymbolTable.scala | 9 +- .../scala/tools/nsc/interpreter/IMain.scala | 4 +- test/files/neg/checksensible.check | 6 +- test/files/neg/overloaded-implicit.check | 6 +- test/files/neg/t1909-object.check | 4 +- test/files/neg/t5675.check | 4 +- test/files/neg/t6567.check | 6 +- test/files/neg/unchecked-refinement.check | 6 +- 20 files changed, 268 insertions(+), 193 deletions(-) create mode 100644 src/compiler/scala/tools/nsc/Reporting.scala create mode 100644 src/reflect/scala/reflect/internal/Reporting.scala diff --git a/bincompat-forward.whitelist.conf b/bincompat-forward.whitelist.conf index 3cd985aeae03..05d929b17714 100644 --- a/bincompat-forward.whitelist.conf +++ b/bincompat-forward.whitelist.conf @@ -234,6 +234,14 @@ filter { { matchName="scala.reflect.runtime.SynchronizedOps.newNestedScope" problemName=MissingMethodProblem + }, + { + matchName="scala.reflect.runtime.JavaUniverse" + problemName=MissingTypesProblem + }, + { + matchName="scala.reflect.runtime.JavaUniverse.inform" + problemName=MissingMethodProblem } ] } diff --git a/src/compiler/scala/reflect/macros/contexts/Parsers.scala b/src/compiler/scala/reflect/macros/contexts/Parsers.scala index 88cfea8157d1..9975bd22a01e 100644 --- a/src/compiler/scala/reflect/macros/contexts/Parsers.scala +++ b/src/compiler/scala/reflect/macros/contexts/Parsers.scala @@ -9,7 +9,10 @@ trait Parsers { def parse(code: String) = { val sreporter = new StoreReporter() - val unit = new CompilationUnit(newSourceFile(code, "")) { override def reporter = sreporter } + val unit = new CompilationUnit(newSourceFile(code, "")) { + override def reporter = sreporter + override def reporting = new PerRunReporting { override def reporter = sreporter } + } val parser = newUnitParser(unit) val tree = gen.mkTreeOrBlock(parser.parseStatsOrPackages()) sreporter.infos.foreach { diff --git a/src/compiler/scala/tools/nsc/CompilationUnits.scala b/src/compiler/scala/tools/nsc/CompilationUnits.scala index 924bb54ddbb5..ae1b94dfa135 100644 --- a/src/compiler/scala/tools/nsc/CompilationUnits.scala +++ b/src/compiler/scala/tools/nsc/CompilationUnits.scala @@ -123,32 +123,27 @@ trait CompilationUnits { global: Global => */ val icode: LinkedHashSet[icodes.IClass] = new LinkedHashSet - def reporter = global.reporter + // reporter and its forwarded methods + def reporter = global.reporter + def reporting = currentRun.reporting - def echo(pos: Position, msg: String) = - reporter.echo(pos, msg) + def echo(pos: Position, msg: String): Unit = reporter.echo(pos, msg) + def error(pos: Position, msg: String): Unit = reporter.error(pos, msg) + def warning(pos: Position, msg: String): Unit = reporter.warning(pos, msg) - def error(pos: Position, msg: String) = - reporter.error(pos, msg) + def deprecationWarning(pos: Position, msg: String): Unit = reporting.deprecationWarning(pos, msg) + def uncheckedWarning(pos: Position, msg: String): Unit = reporting.uncheckedWarning(pos, msg) + def inlinerWarning(pos: Position, msg: String): Unit = reporting.inlinerWarning(pos, msg) + def featureWarning(pos: Position, featureName: String, featureDesc: String, featureTrait: Symbol, construct: => String = "", + required: Boolean): Unit = reporting.featureWarning(pos, featureName, featureDesc, featureTrait, construct, required) - def warning(pos: Position, msg: String) = - reporter.warning(pos, msg) - - def deprecationWarning(pos: Position, msg: String) = - currentRun.deprecationWarnings0.warn(pos, msg) - - def uncheckedWarning(pos: Position, msg: String) = - currentRun.uncheckedWarnings0.warn(pos, msg) - - def inlinerWarning(pos: Position, msg: String) = - currentRun.inlinerWarnings.warn(pos, msg) - - def incompleteInputError(pos: Position, msg:String) = - reporter.incompleteInputError(pos, msg) + // repl + def incompleteHandled: Boolean = reporting.incompleteHandled + def incompleteInputError(pos: Position, msg:String): Unit = reporting.incompleteInputError(pos, msg) // used by the IDE -- TODO: don't use reporter to communicate comments from parser to IDE! - def comment(pos: Position, msg: String): Unit = - reporter.comment(pos, msg) + def comment(pos: Position, msg: String): Unit = reporter.comment(pos, msg) + /** Is this about a .java source file? */ lazy val isJava = source.file.name.endsWith(".java") diff --git a/src/compiler/scala/tools/nsc/CompileServer.scala b/src/compiler/scala/tools/nsc/CompileServer.scala index 6f068e179c85..1f3a4237eb3d 100644 --- a/src/compiler/scala/tools/nsc/CompileServer.scala +++ b/src/compiler/scala/tools/nsc/CompileServer.scala @@ -7,7 +7,7 @@ package scala.tools.nsc import java.io.PrintStream import scala.tools.nsc.reporters.{Reporter, ConsoleReporter} -import scala.reflect.internal.util.FakePos //Position +import scala.reflect.internal.util.{FakePos, Position} import scala.tools.util.SocketServer import settings.FscSettings @@ -37,7 +37,7 @@ class StandardCompileServer extends SocketServer { /** Create a new compiler instance */ def newGlobal(settings: Settings, reporter: Reporter) = new Global(settings, reporter) { - override def inform(msg: String) = out.println(msg) + override def inform(pos: Position, msg: String) = out.println(msg) } override def timeout() { diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 836203e80df6..daf69ffc3f03 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -44,7 +44,8 @@ class Global(var currentSettings: Settings, var reporter: Reporter) with Trees with Printers with DocComments - with Positions { self => + with Positions + with Reporting { self => // the mirror -------------------------------------------------- @@ -227,20 +228,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) */ def registerTopLevelSym(sym: Symbol) {} -// ------------------ Reporting ------------------------------------- - - // not deprecated yet, but a method called "error" imported into - // nearly every trait really must go. For now using globalError. - def error(msg: String) = globalError(msg) - - override def inform(msg: String) = inform(NoPosition, msg) - override def globalError(msg: String) = globalError(NoPosition, msg) - override def warning(msg: String) = warning(NoPosition, msg) - override def deprecationWarning(pos: Position, msg: String) = currentUnit.deprecationWarning(pos, msg) - - def globalError(pos: Position, msg: String) = reporter.error(pos, msg) - def warning(pos: Position, msg: String) = if (settings.fatalWarnings) globalError(pos, msg) else reporter.warning(pos, msg) - def inform(pos: Position, msg: String) = reporter.echo(pos, msg) +// ------------------ Debugging ------------------------------------- // Getting in front of Predef's asserts to supplement with more info. // This has the happy side effect of masking the one argument forms @@ -263,12 +251,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter) require(requirement, "") } - // Needs to call error to make sure the compile fails. - override def abort(msg: String): Nothing = { - error(msg) - super.abort(msg) - } - @inline final def ifDebug(body: => Unit) { if (settings.debug) body @@ -1063,6 +1045,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) def currentUnit: CompilationUnit = if (currentRun eq null) NoCompilationUnit else currentRun.currentUnit def currentSource: SourceFile = if (currentUnit.exists) currentUnit.source else lastSeenSourceFile def currentFreshNameCreator = currentUnit.fresh + def currentReporting = currentRun.reporting def isGlobalInitialized = ( definitions.isDefinitionsInitialized @@ -1110,45 +1093,41 @@ class Global(var currentSettings: Settings, var reporter: Reporter) /** Don't want to introduce new errors trying to report errors, * so swallow exceptions. */ - override def supplementErrorMessage(errorMessage: String): String = { - if (currentRun.supplementedError) errorMessage - else try { - currentRun.supplementedError = true - val tree = analyzer.lastTreeToTyper - val sym = tree.symbol - val tpe = tree.tpe - val site = lastSeenContext.enclClassOrMethod.owner - val pos_s = if (tree.pos.isDefined) s"line ${tree.pos.line} of ${tree.pos.source.file}" else "" - val context_s = try { - // Taking 3 before, 3 after the fingered line. - val start = 0 max (tree.pos.line - 3) - val xs = scala.reflect.io.File(tree.pos.source.file.file).lines drop start take 7 - val strs = xs.zipWithIndex map { case (line, idx) => f"${start + idx}%6d $line" } - strs.mkString("== Source file context for tree position ==\n\n", "\n", "") - } - catch { case t: Exception => devWarning("" + t) ; "" } - - val info1 = formatExplain( - "while compiling" -> currentSource.path, - "during phase" -> ( if (globalPhase eq phase) phase else "globalPhase=%s, enteringPhase=%s".format(globalPhase, phase) ), - "library version" -> scala.util.Properties.versionString, - "compiler version" -> Properties.versionString, - "reconstructed args" -> settings.recreateArgs.mkString(" ") - ) - val info2 = formatExplain( - "last tree to typer" -> tree.summaryString, - "tree position" -> pos_s, - "tree tpe" -> tpe, - "symbol" -> Option(sym).fold("null")(_.debugLocationString), - "symbol definition" -> Option(sym).fold("null")(s => s.defString + s" (a ${s.shortSymbolClass})"), - "symbol package" -> sym.enclosingPackage.fullName, - "symbol owners" -> ownerChainString(sym), - "call site" -> (site.fullLocationString + " in " + site.enclosingPackage) - ) - ("\n " + errorMessage + "\n" + info1) :: info2 :: context_s :: Nil mkString "\n\n" + def supplementTyperState(errorMessage: String): String = try { + val tree = analyzer.lastTreeToTyper + val sym = tree.symbol + val tpe = tree.tpe + val site = lastSeenContext.enclClassOrMethod.owner + val pos_s = if (tree.pos.isDefined) s"line ${tree.pos.line} of ${tree.pos.source.file}" else "" + val context_s = try { + // Taking 3 before, 3 after the fingered line. + val start = 0 max (tree.pos.line - 3) + val xs = scala.reflect.io.File(tree.pos.source.file.file).lines drop start take 7 + val strs = xs.zipWithIndex map { case (line, idx) => f"${start + idx}%6d $line" } + strs.mkString("== Source file context for tree position ==\n\n", "\n", "") } - catch { case _: Exception | _: TypeError => errorMessage } - } + catch { case t: Exception => devWarning("" + t) ; "" } + + val info1 = formatExplain( + "while compiling" -> currentSource.path, + "during phase" -> ( if (globalPhase eq phase) phase else "globalPhase=%s, enteringPhase=%s".format(globalPhase, phase) ), + "library version" -> scala.util.Properties.versionString, + "compiler version" -> Properties.versionString, + "reconstructed args" -> settings.recreateArgs.mkString(" ") + ) + val info2 = formatExplain( + "last tree to typer" -> tree.summaryString, + "tree position" -> pos_s, + "tree tpe" -> tpe, + "symbol" -> Option(sym).fold("null")(_.debugLocationString), + "symbol definition" -> Option(sym).fold("null")(s => s.defString + s" (a ${s.shortSymbolClass})"), + "symbol package" -> sym.enclosingPackage.fullName, + "symbol owners" -> ownerChainString(sym), + "call site" -> (site.fullLocationString + " in " + site.enclosingPackage) + ) + ("\n " + errorMessage + "\n" + info1) :: info2 :: context_s :: Nil mkString "\n\n" + } catch { case _: Exception | _: TypeError => errorMessage } + /** The id of the currently active run */ @@ -1160,19 +1139,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter) inform("[running phase " + ph.name + " on " + currentRun.size + " compilation units]") } - /** Collects for certain classes of warnings during this run. */ - class ConditionalWarning(what: String, option: Settings#BooleanSetting) { - val warnings = mutable.LinkedHashMap[Position, String]() - def warn(pos: Position, msg: String) = - if (option) reporter.warning(pos, msg) - else if (!(warnings contains pos)) warnings += ((pos, msg)) - def summarize() = - if (warnings.nonEmpty && (option.isDefault || settings.fatalWarnings)){ - val warningEvent = if (warnings.size > 1) s"were ${ warnings.size } $what warnings" else s"was one $what warning" - warning(s"there $warningEvent; re-run with ${ option.name } for details") - } - } - def newSourceFile(code: String, filename: String = "") = new BatchSourceFile(filename, code) @@ -1199,38 +1165,12 @@ class Global(var currentSettings: Settings, var reporter: Reporter) /** The currently compiled unit; set from GlobalPhase */ var currentUnit: CompilationUnit = NoCompilationUnit - // This change broke sbt; I gave it the thrilling name of uncheckedWarnings0 so - // as to recover uncheckedWarnings for its ever-fragile compiler interface. - val deprecationWarnings0 = new ConditionalWarning("deprecation", settings.deprecation) - val uncheckedWarnings0 = new ConditionalWarning("unchecked", settings.unchecked) - val featureWarnings = new ConditionalWarning("feature", settings.feature) - val inlinerWarnings = new ConditionalWarning("inliner", settings.YinlinerWarnings) - val allConditionalWarnings = List(deprecationWarnings0, uncheckedWarnings0, featureWarnings, inlinerWarnings) - - def uncheckedWarnings: List[(Position, String)] = uncheckedWarnings0.warnings.toList // used in sbt - def deprecationWarnings: List[(Position, String)] = deprecationWarnings0.warnings.toList // used in sbt - - def reportAdditionalErrors(): Unit = { - if (!reporter.hasErrors) { - if (reporter.hasWarnings && settings.fatalWarnings) - globalError("No warnings can be incurred under -Xfatal-warnings.") - - allConditionalWarnings foreach (_.summarize()) - - if (seenMacroExpansionsFallingBack) - warning("some macros could not be expanded and code fell back to overridden methods;"+ - "\nrecompiling with generated classfiles on the classpath might help.") - // todo: migrationWarnings - } - } - - var reportedFeature = Set[Symbol]() - - /** Has any macro expansion used a fallback during this run? */ - var seenMacroExpansionsFallingBack = false + val reporting = new PerRunReporting - /** Have we already supplemented the error message of a compiler crash? */ - private[nsc] final var supplementedError = false + // used in sbt + def uncheckedWarnings: List[(Position, String)] = reporting.uncheckedWarnings + // used in sbt + def deprecationWarnings: List[(Position, String)] = reporting.deprecationWarnings private class SyncedCompilationBuffer { self => private val underlying = new mutable.ArrayBuffer[CompilationUnit] @@ -1590,7 +1530,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) def checkDeprecations() = { checkDeprecatedSettings(newCompilationUnit("")) - reportAdditionalErrors() + reporting.summarizeErrors() } val units = sources map scripted map (new CompilationUnit(_)) @@ -1660,7 +1600,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) advancePhase() } - reportAdditionalErrors() + reporting.summarizeErrors() if (traceSymbolActivity) units map (_.body) foreach (traceSymbols recordSymbolsInTree _) diff --git a/src/compiler/scala/tools/nsc/Reporting.scala b/src/compiler/scala/tools/nsc/Reporting.scala new file mode 100644 index 000000000000..614eb4f21280 --- /dev/null +++ b/src/compiler/scala/tools/nsc/Reporting.scala @@ -0,0 +1,132 @@ +/* NSC -- new Scala compiler + * Copyright 2005-2014 LAMP/EPFL, Typesafe Inc. + * @author Adriaan Moors + */ + +package scala +package tools +package nsc + +import reporters.{ Reporter, ConsoleReporter } +import scala.collection.{ mutable, immutable } + +trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions with CompilationUnits with scala.reflect.api.Symbols => + def settings: Settings + def reporter: Reporter + def currentReporting: PerRunReporting + + def supplementTyperState(errorMessage: String): String + + // not deprecated yet, but a method called "error" imported into + // nearly every trait really must go. For now using globalError. + def error(msg: String) = globalError(msg) + + override def inform(pos: Position, msg: String) = reporter.echo(pos, msg) + override def warning(pos: Position, msg: String) = reporter.warning(pos, msg) + override def globalError(pos: Position, msg: String) = reporter.error(pos, msg) + + override def deprecationWarning(pos: Position, msg: String) = currentReporting.deprecationWarning(pos, msg) + override def supplementErrorMessage(errorMessage: String) = currentReporting.supplementErrorMessage(errorMessage) + + // a new instance of this class is created for every Run (access the current instance via `currentReporting`) + class PerRunReporting { + // NOTE: scala.reflect.macros.Parsers#parse relies on everything related to reporting going through this def... + // TODO: can we rework this to avoid the indirection/fragility? + def reporter = Reporting.this.reporter + + /** Collects for certain classes of warnings during this run. */ + private class ConditionalWarning(what: String, option: Settings#BooleanSetting) { + val warnings = mutable.LinkedHashMap[Position, String]() + def warn(pos: Position, msg: String) = + if (option) reporter.warning(pos, msg) + else if (!(warnings contains pos)) warnings += ((pos, msg)) + def summarize() = + if (warnings.nonEmpty && (option.isDefault || settings.fatalWarnings)) { + val numWarnings = warnings.size + val warningEvent = // TODO use scala.reflect.internal.util.StringOps.countElementsAsString(numWarnings, s"$what warning") + if (numWarnings > 1) s"were $numWarnings $what warnings" + else s"was one $what warning" + + reporter.warning(NoPosition, s"there $warningEvent; re-run with ${option.name} for details") + } + } + + // This change broke sbt; I gave it the thrilling name of uncheckedWarnings0 so + // as to recover uncheckedWarnings for its ever-fragile compiler interface. + private val _deprecationWarnings = new ConditionalWarning("deprecation", settings.deprecation) + private val _uncheckedWarnings = new ConditionalWarning("unchecked", settings.unchecked) + private val _featureWarnings = new ConditionalWarning("feature", settings.feature) + private val _inlinerWarnings = new ConditionalWarning("inliner", settings.YinlinerWarnings) + private val _allConditionalWarnings = List(_deprecationWarnings, _uncheckedWarnings, _featureWarnings, _inlinerWarnings) + + def deprecationWarning(pos: Position, msg: String): Unit = _deprecationWarnings.warn(pos, msg) + def uncheckedWarning(pos: Position, msg: String): Unit = _uncheckedWarnings.warn(pos, msg) + def featureWarning(pos: Position, msg: String): Unit = _featureWarnings.warn(pos, msg) + def inlinerWarning(pos: Position, msg: String): Unit = _inlinerWarnings.warn(pos, msg) + + def deprecationWarnings = _deprecationWarnings.warnings.toList + def uncheckedWarnings = _uncheckedWarnings.warnings.toList + def featureWarnings = _featureWarnings.warnings.toList + def inlinerWarnings = _inlinerWarnings.warnings.toList + + def allConditionalWarnings = _allConditionalWarnings flatMap (_.warnings) + + private[this] var reportedFeature = Set[Symbol]() + def featureWarning(pos: Position, featureName: String, featureDesc: String, featureTrait: Symbol, construct: => String = "", required: Boolean): Unit = { + val req = if (required) "needs to" else "should" + val fqname = "scala.language." + featureName + val explain = ( + if (reportedFeature contains featureTrait) "" else + s"""| + |This can be achieved by adding the import clause 'import $fqname' + |or by setting the compiler option -language:$featureName. + |See the Scala docs for value $fqname for a discussion + |why the feature $req be explicitly enabled.""".stripMargin + ) + reportedFeature += featureTrait + + val msg = s"$featureDesc $req be enabled\nby making the implicit value $fqname visible.$explain" replace ("#", construct) + if (required) reporter.error(pos, msg) + else featureWarning(pos, msg) + } + + /** Has any macro expansion used a fallback during this run? */ + var seenMacroExpansionsFallingBack = false + + def summarizeErrors(): Unit = if (!reporter.hasErrors) { + _allConditionalWarnings foreach (_.summarize()) + + if (seenMacroExpansionsFallingBack) + reporter.warning(NoPosition, "some macros could not be expanded and code fell back to overridden methods;"+ + "\nrecompiling with generated classfiles on the classpath might help.") + + // todo: migrationWarnings + + if (settings.fatalWarnings && reporter.hasWarnings) + reporter.error(NoPosition, "No warnings can be incurred under -Xfatal-warnings.") + } + + // for repl + private[this] var incompleteHandler: (Position, String) => Unit = null + def withIncompleteHandler[T](handler: (Position, String) => Unit)(thunk: => T) = { + val saved = incompleteHandler + incompleteHandler = handler + try thunk + finally incompleteHandler = saved + } + + def incompleteHandled = incompleteHandler != null + def incompleteInputError(pos: Position, msg: String): Unit = + if (incompleteHandled) incompleteHandler(pos, msg) + else reporter.error(pos, msg) + + /** Have we already supplemented the error message of a compiler crash? */ + private[this] var supplementedError = false + def supplementErrorMessage(errorMessage: String): String = + if (supplementedError) errorMessage + else { + supplementedError = true + supplementTyperState(errorMessage) + } + } +} \ No newline at end of file diff --git a/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala b/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala index 3a695c6f59c7..3d8a7d2e556b 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala @@ -83,7 +83,7 @@ abstract class SyntaxAnalyzer extends SubComponent with Parsers with MarkupParse private def initialUnitBody(unit: CompilationUnit): Tree = { if (unit.isJava) new JavaUnitParser(unit).parse() - else if (global.reporter.incompleteHandled) newUnitParser(unit).parse() + else if (unit.incompleteHandled) newUnitParser(unit).parse() else newUnitParser(unit).smartParse() } diff --git a/src/compiler/scala/tools/nsc/reporters/Reporter.scala b/src/compiler/scala/tools/nsc/reporters/Reporter.scala index 1a8794d21790..b617e7b530e9 100644 --- a/src/compiler/scala/tools/nsc/reporters/Reporter.scala +++ b/src/compiler/scala/tools/nsc/reporters/Reporter.scala @@ -53,15 +53,6 @@ abstract class Reporter { override def toString: String = "ERROR" } - private var incompleteHandler: (Position, String) => Unit = null - def incompleteHandled = incompleteHandler != null - def withIncompleteHandler[T](handler: (Position, String) => Unit)(thunk: => T) = { - val saved = incompleteHandler - incompleteHandler = handler - try thunk - finally incompleteHandler = saved - } - // used by sbt (via unit.cancel) to cancel a compile (see hasErrors) var cancelled: Boolean = false @@ -71,12 +62,6 @@ abstract class Reporter { // overridden by sbt def hasWarnings: Boolean = WARNING.count > 0 - // TODO - def incompleteInputError(pos: Position, msg: String): Unit = { - if (incompleteHandled) incompleteHandler(pos, msg) - else error(pos, msg) - } - // overridden by sbt, IDE -- should move out of this interface // it's unrelated to reporting (IDE receives comments from ScaladocAnalyzer) def comment(pos: Position, msg: String): Unit = {} diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala index ef74beec62c8..9c22688581e7 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala @@ -714,7 +714,7 @@ trait Macros extends MacroRuntimes with Traces with Helpers { sealed abstract class MacroStatus(val result: Tree) case class Success(expanded: Tree) extends MacroStatus(expanded) - case class Fallback(fallback: Tree) extends MacroStatus(fallback) { currentRun.seenMacroExpansionsFallingBack = true } + case class Fallback(fallback: Tree) extends MacroStatus(fallback) { currentRun.reporting.seenMacroExpansionsFallingBack = true } case class Delayed(delayed: Tree) extends MacroStatus(delayed) case class Skipped(skipped: Tree) extends MacroStatus(skipped) case class Failure(failure: Tree) extends MacroStatus(failure) @@ -788,7 +788,7 @@ trait Macros extends MacroRuntimes with Traces with Helpers { } } catch { case ex: Throwable => - popMacroContext() + if (openMacros.nonEmpty) popMacroContext() // weirdly we started popping on an empty stack when refactoring fatalWarnings logic val realex = ReflectionUtils.unwrapThrowable(ex) realex match { case ex: AbortMacroException => MacroGeneratedAbort(expandee, ex) diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 9a4d5e3c0676..059b58c94338 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -746,21 +746,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper if (!OK) { val Some(AnnotationInfo(_, List(Literal(Constant(featureDesc: String)), Literal(Constant(required: Boolean))), _)) = featureTrait getAnnotation LanguageFeatureAnnot - val req = if (required) "needs to" else "should" - val fqname = "scala.language." + featureName - val explain = ( - if (currentRun.reportedFeature contains featureTrait) "" else - s"""| - |This can be achieved by adding the import clause 'import $fqname' - |or by setting the compiler option -language:$featureName. - |See the Scala docs for value $fqname for a discussion - |why the feature $req be explicitly enabled.""".stripMargin - ) - currentRun.reportedFeature += featureTrait - - val msg = s"$featureDesc $req be enabled\nby making the implicit value $fqname visible.$explain" replace ("#", construct) - if (required) unit.error(pos, msg) - else currentRun.featureWarnings.warn(pos, msg) + unit.featureWarning(pos, featureName, featureDesc, featureTrait, construct, required) } OK } diff --git a/src/reflect/scala/reflect/internal/Positions.scala b/src/reflect/scala/reflect/internal/Positions.scala index 01fba1efc16c..c16d8778d992 100644 --- a/src/reflect/scala/reflect/internal/Positions.scala +++ b/src/reflect/scala/reflect/internal/Positions.scala @@ -23,13 +23,10 @@ import scala.collection.mutable.ListBuffer * Otherwise, the singleton consisting of the node itself. */ trait Positions extends api.Positions { self: SymbolTable => - type Position = scala.reflect.internal.util.Position val NoPosition = scala.reflect.internal.util.NoPosition implicit val PositionTag = ClassTag[Position](classOf[Position]) - def inform(msg: String): Unit - def useOffsetPositions: Boolean = true /** A position that wraps a set of trees. @@ -100,7 +97,7 @@ trait Positions extends api.Positions { self: SymbolTable => inform("\nWhile validating #" + tree.id) inform(treeStatus(tree)) inform("\nChildren:") - tree.children map (t => " " + treeStatus(t, tree)) foreach inform + tree.children foreach (t => inform(" " + treeStatus(t, tree))) inform("=======") throw new ValidateException(msg) } @@ -109,7 +106,7 @@ trait Positions extends api.Positions { self: SymbolTable => if (!tree.isEmpty && tree.canHaveAttrs) { if (settings.Yposdebug && (settings.verbose || settings.Yrangepos)) - println("[%10s] %s".format("validate", treeStatus(tree, encltree))) + inform("[%10s] %s".format("validate", treeStatus(tree, encltree))) if (!tree.pos.isDefined) positionError("Unpositioned tree #"+tree.id) { @@ -176,7 +173,7 @@ trait Positions extends api.Positions { self: SymbolTable => case r :: rs1 => assert(!t.pos.isTransparent) if (r.isFree && (r.pos includes t.pos)) { -// println("subdividing "+r+"/"+t.pos) +// inform("subdividing "+r+"/"+t.pos) maybeFree(t.pos.end, r.pos.end) ::: List(Range(t.pos, t)) ::: maybeFree(r.pos.start, t.pos.start) ::: rs1 } else { if (!r.isFree && (r.pos overlaps t.pos)) conflicting += r.tree @@ -225,7 +222,7 @@ trait Positions extends api.Positions { self: SymbolTable => } } catch { case ex: Exception => - println("error while set children pos "+pos+" of "+trees) + inform("error while set children pos "+pos+" of "+trees) throw ex } diff --git a/src/reflect/scala/reflect/internal/Reporting.scala b/src/reflect/scala/reflect/internal/Reporting.scala new file mode 100644 index 000000000000..e88e76575064 --- /dev/null +++ b/src/reflect/scala/reflect/internal/Reporting.scala @@ -0,0 +1,32 @@ +/* NSC -- new Scala compiler + * Copyright 2005-2014 LAMP/EPFL, Typesafe Inc. + * @author Adriaan Moors + */ + +package scala +package reflect +package internal + +trait Reporting { self : Positions => + def inform(msg: String): Unit = inform(NoPosition, msg) + def warning(msg: String): Unit = warning(NoPosition, msg) + // globalError(msg: String) used to abort -- not sure that was a good idea, so I made it more regular + // (couldn't find any uses that relied on old behavior) + def globalError(msg: String): Unit = globalError(NoPosition, msg) + + def abort(msg: String): Nothing = { + val augmented = supplementErrorMessage(msg) + // Needs to call error to make sure the compile fails. + globalError(augmented) + throw new FatalError(augmented) + } + + def inform(pos: Position, msg: String) = Console.out.println(msg) + def warning(pos: Position, msg: String) = Console.err.println(msg) + def globalError(pos: Position, msg: String) = Console.err.println(msg) + + def deprecationWarning(pos: Position, msg: String): Unit = warning(msg) + + /** Overridden when we know more about what was happening during a failure. */ + def supplementErrorMessage(msg: String): String = msg +} \ No newline at end of file diff --git a/src/reflect/scala/reflect/internal/SymbolTable.scala b/src/reflect/scala/reflect/internal/SymbolTable.scala index c76dedbff44c..ed5c68fe82f7 100644 --- a/src/reflect/scala/reflect/internal/SymbolTable.scala +++ b/src/reflect/scala/reflect/internal/SymbolTable.scala @@ -46,16 +46,12 @@ abstract class SymbolTable extends macros.Universe with pickling.Translations with FreshNames with Internals + with Reporting { val gen = new InternalTreeGen { val global: SymbolTable.this.type = SymbolTable.this } def log(msg: => AnyRef): Unit - def deprecationWarning(pos: Position, msg: String): Unit = warning(msg) - def warning(msg: String): Unit = Console.err.println(msg) - def inform(msg: String): Unit = Console.err.println(msg) - def globalError(msg: String): Unit = abort(msg) - def abort(msg: String): Nothing = throw new FatalError(supplementErrorMessage(msg)) protected def elapsedMessage(msg: String, start: Long) = msg + " in " + (TimeUnit.NANOSECONDS.toMillis(System.nanoTime()) - start) + "ms" @@ -82,9 +78,6 @@ abstract class SymbolTable extends macros.Universe /** Prints a stack trace if -Ydebug or equivalent was given, otherwise does nothing. */ def debugStack(t: Throwable): Unit = devWarning(throwableAsString(t)) - /** Overridden when we know more about what was happening during a failure. */ - def supplementErrorMessage(msg: String): String = msg - private[scala] def printCaller[T](msg: String)(result: T) = { Console.err.println("%s: %s\nCalled from: %s".format(msg, result, (new Throwable).getStackTrace.drop(2).take(50).mkString("\n"))) diff --git a/src/repl/scala/tools/nsc/interpreter/IMain.scala b/src/repl/scala/tools/nsc/interpreter/IMain.scala index 2deeed2be318..8ea8759ee5e7 100644 --- a/src/repl/scala/tools/nsc/interpreter/IMain.scala +++ b/src/repl/scala/tools/nsc/interpreter/IMain.scala @@ -793,7 +793,7 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set } ((pos, msg)) :: loop(filtered) } - val warnings = loop(run.allConditionalWarnings flatMap (_.warnings)) + val warnings = loop(run.reporting.allConditionalWarnings) if (warnings.nonEmpty) mostRecentWarnings = warnings } @@ -1121,7 +1121,7 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set def apply(line: String): Result = debugging(s"""parse("$line")""") { var isIncomplete = false - reporter.withIncompleteHandler((_, _) => isIncomplete = true) { + currentRun.reporting.withIncompleteHandler((_, _) => isIncomplete = true) { reporter.reset() val trees = newUnitParser(line).parseStats() if (reporter.hasErrors) Error diff --git a/test/files/neg/checksensible.check b/test/files/neg/checksensible.check index 38cc5ec447ad..1b53fa5fb9d0 100644 --- a/test/files/neg/checksensible.check +++ b/test/files/neg/checksensible.check @@ -97,7 +97,7 @@ checksensible.scala:84: warning: comparing values of types EqEqRefTest.this.C3 a checksensible.scala:95: warning: comparing values of types Unit and Int using `!=' will always yield true while ((c = in.read) != -1) ^ +warning: there were 3 deprecation warnings; re-run with -deprecation for details error: No warnings can be incurred under -Xfatal-warnings. -error: there were 3 deprecation warnings; re-run with -deprecation for details -33 warnings found -two errors found +34 warnings found +one error found diff --git a/test/files/neg/overloaded-implicit.check b/test/files/neg/overloaded-implicit.check index d9594d126acb..5cf6ac528b5a 100644 --- a/test/files/neg/overloaded-implicit.check +++ b/test/files/neg/overloaded-implicit.check @@ -4,7 +4,7 @@ overloaded-implicit.scala:2: warning: parameterized overloaded implicit methods overloaded-implicit.scala:3: warning: parameterized overloaded implicit methods are not visible as view bounds implicit def imp1[T](x: Set[T]): Map[T, T] = Map() ^ +warning: there were 4 feature warnings; re-run with -feature for details error: No warnings can be incurred under -Xfatal-warnings. -error: there were 4 feature warnings; re-run with -feature for details -two warnings found -two errors found +three warnings found +one error found diff --git a/test/files/neg/t1909-object.check b/test/files/neg/t1909-object.check index 401c1f7ebf72..7141c84d4bd0 100644 --- a/test/files/neg/t1909-object.check +++ b/test/files/neg/t1909-object.check @@ -1,4 +1,6 @@ -t1909-object.scala:4: error: !!! SI-1909 Unable to STATICally lift object InnerTrouble$1, which is defined in the self- or super-constructor call of class Kaboom. A VerifyError is likely. +t1909-object.scala:4: warning: !!! SI-1909 Unable to STATICally lift object InnerTrouble$1, which is defined in the self- or super-constructor call of class Kaboom. A VerifyError is likely. object InnerTrouble ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found one error found diff --git a/test/files/neg/t5675.check b/test/files/neg/t5675.check index 13226935dcc8..3b3b2fa04ceb 100644 --- a/test/files/neg/t5675.check +++ b/test/files/neg/t5675.check @@ -1,2 +1,4 @@ -error: there was one feature warning; re-run with -feature for details +warning: there was one feature warning; re-run with -feature for details +error: No warnings can be incurred under -Xfatal-warnings. +one warning found one error found diff --git a/test/files/neg/t6567.check b/test/files/neg/t6567.check index 3243fde0cd19..f42f157371e0 100644 --- a/test/files/neg/t6567.check +++ b/test/files/neg/t6567.check @@ -4,7 +4,7 @@ t6567.scala:8: warning: Suspicious application of an implicit view (Test.this.a2 t6567.scala:10: warning: Suspicious application of an implicit view (Test.this.a2b) in the argument to Option.apply. val b: Option[B] = Option(a) ^ +warning: there was one feature warning; re-run with -feature for details error: No warnings can be incurred under -Xfatal-warnings. -error: there was one feature warning; re-run with -feature for details -two warnings found -two errors found +three warnings found +one error found diff --git a/test/files/neg/unchecked-refinement.check b/test/files/neg/unchecked-refinement.check index b49e47fcbb59..0bb944621be1 100644 --- a/test/files/neg/unchecked-refinement.check +++ b/test/files/neg/unchecked-refinement.check @@ -10,7 +10,7 @@ unchecked-refinement.scala:23: warning: a pattern match on a refinement type is unchecked-refinement.scala:24: warning: a pattern match on a refinement type is unchecked /* nowarn - todo */ case x: AnyRef { def size: Int } if b => x.size // this could/should do a static conformance test and not warn ^ +warning: there was one feature warning; re-run with -feature for details error: No warnings can be incurred under -Xfatal-warnings. -error: there was one feature warning; re-run with -feature for details -four warnings found -two errors found +5 warnings found +one error found From 62c8f90f3105b8f19a9f29f104ff232438372c73 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Sat, 14 Jun 2014 00:38:30 +0200 Subject: [PATCH 359/826] Uniformly route reporting through reporter. Sharpen interfaces, reduce footprint of Reporting trait. Ideally, all reporting should indirect through reporter, and the `Reporting` trait itself should be restricted to a single method that retrieves the current `reporter`. Pull up some more reporting to reflect.internal. Would like to do more, but need to move partest to the reflect.internal interface first. (Its `errorCount` relies on `ERROR.count` in `tools.nsc.Reporter`.) --- bincompat-forward.whitelist.conf | 2 +- src/compiler/scala/tools/nsc/Reporting.scala | 12 ++-- .../nsc/reporters/AbstractReporter.scala | 11 +-- .../scala/tools/nsc/reporters/Reporter.scala | 69 ++++++++----------- .../scala/reflect/internal/Reporting.scala | 65 +++++++++++++++-- .../scala/reflect/runtime/JavaUniverse.scala | 10 ++- .../symtab/SymbolTableForUnitTesting.scala | 5 ++ 7 files changed, 116 insertions(+), 58 deletions(-) diff --git a/bincompat-forward.whitelist.conf b/bincompat-forward.whitelist.conf index 05d929b17714..dbf0807999a1 100644 --- a/bincompat-forward.whitelist.conf +++ b/bincompat-forward.whitelist.conf @@ -240,7 +240,7 @@ filter { problemName=MissingTypesProblem }, { - matchName="scala.reflect.runtime.JavaUniverse.inform" + matchName="scala.reflect.runtime.JavaUniverse.reporter" problemName=MissingMethodProblem } ] diff --git a/src/compiler/scala/tools/nsc/Reporting.scala b/src/compiler/scala/tools/nsc/Reporting.scala index 614eb4f21280..a8fd3bec763d 100644 --- a/src/compiler/scala/tools/nsc/Reporting.scala +++ b/src/compiler/scala/tools/nsc/Reporting.scala @@ -10,9 +10,15 @@ package nsc import reporters.{ Reporter, ConsoleReporter } import scala.collection.{ mutable, immutable } +/** Provides delegates to the reporter doing the actual work. + * PerRunReporting implements per-Run stateful info tracking and reporting + * + * TODO: make reporting configurable + */ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions with CompilationUnits with scala.reflect.api.Symbols => def settings: Settings - def reporter: Reporter + + // == currentRun.reporting def currentReporting: PerRunReporting def supplementTyperState(errorMessage: String): String @@ -21,10 +27,6 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w // nearly every trait really must go. For now using globalError. def error(msg: String) = globalError(msg) - override def inform(pos: Position, msg: String) = reporter.echo(pos, msg) - override def warning(pos: Position, msg: String) = reporter.warning(pos, msg) - override def globalError(pos: Position, msg: String) = reporter.error(pos, msg) - override def deprecationWarning(pos: Position, msg: String) = currentReporting.deprecationWarning(pos, msg) override def supplementErrorMessage(errorMessage: String) = currentReporting.supplementErrorMessage(errorMessage) diff --git a/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala b/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala index 16d432438a8d..6c592ead0d50 100644 --- a/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala +++ b/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala @@ -62,12 +62,13 @@ abstract class AbstractReporter extends Reporter { */ private def testAndLog(pos: Position, severity: Severity, msg: String): Boolean = pos != null && pos.isDefined && { - val fpos = pos.focus + val fpos = pos.focus val suppress = positions(fpos) match { - case ERROR => true // already error at position - case highest if highest > severity => true // already message higher than present severity - case `severity` => messages(fpos) contains msg // already issued this exact message - case _ => false // good to go + case ERROR => true // already error at position + case highest + if highest.id > severity.id => true // already message higher than present severity + case `severity` => messages(fpos) contains msg // already issued this exact message + case _ => false // good to go } suppress || { diff --git a/src/compiler/scala/tools/nsc/reporters/Reporter.scala b/src/compiler/scala/tools/nsc/reporters/Reporter.scala index b617e7b530e9..5b576a547d4c 100644 --- a/src/compiler/scala/tools/nsc/reporters/Reporter.scala +++ b/src/compiler/scala/tools/nsc/reporters/Reporter.scala @@ -10,59 +10,48 @@ import scala.reflect.internal.util._ /** Report information, warnings and errors. * - * This describes the stable interface for issuing information, warnings and errors. + * This describes the internal interface for issuing information, warnings and errors. * The only abstract method in this class must be info0. + * + * TODO: Move external clients (sbt/ide/partest) to reflect.internal.Reporter + * This interface should be considered private to the compiler. */ -abstract class Reporter { - protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit - +abstract class Reporter extends scala.reflect.internal.Reporter { /** Informational messages. If `!force`, they may be suppressed. */ final def info(pos: Position, msg: String, force: Boolean): Unit = info0(pos, msg, INFO, force) /** For sending a message which should not be labeled as a warning/error, * but also shouldn't require -verbose to be visible. */ - def echo(msg: String): Unit = info(NoPosition, msg, force = true) - def echo(pos: Position, msg: String): Unit = info(pos, msg, force = true) - - /** Warnings and errors. */ - def warning(pos: Position, msg: String): Unit = info0(pos, msg, WARNING, force = false) - def error(pos: Position, msg: String): Unit = info0(pos, msg, ERROR, force = false) - - def flush(): Unit = { } + def echo(msg: String): Unit = info(NoPosition, msg, force = true) - // overridden by sbt, IDE - def reset(): Unit = { - INFO.count = 0 - WARNING.count = 0 - ERROR.count = 0 - cancelled = false - } - - object severity extends Enumeration - class Severity(val id: Int) extends severity.Value { - var count: Int = 0 - } - val INFO = new Severity(0) { - override def toString: String = "INFO" - } - val WARNING = new Severity(1) { - override def toString: String = "WARNING" - } - val ERROR = new Severity(2) { - override def toString: String = "ERROR" - } + // overridden by sbt, IDE -- should not be in the reporting interface + // (IDE receives comments from ScaladocAnalyzer using this hook method) + // TODO: IDE should override a hook method in the parser instead + def comment(pos: Position, msg: String): Unit = {} // used by sbt (via unit.cancel) to cancel a compile (see hasErrors) + // TODO: figure out how sbt uses this, come up with a separate interface for controlling the build var cancelled: Boolean = false - // overridden by sbt - def hasErrors: Boolean = ERROR.count > 0 || cancelled + override def hasErrors: Boolean = super.hasErrors || cancelled - // overridden by sbt - def hasWarnings: Boolean = WARNING.count > 0 + override def reset(): Unit = { + super.reset() + cancelled = false + } - // overridden by sbt, IDE -- should move out of this interface - // it's unrelated to reporting (IDE receives comments from ScaladocAnalyzer) - def comment(pos: Position, msg: String): Unit = {} + // the below is copy/pasted from ReporterImpl for now + // partest expects this inner class + // TODO: rework partest to use the scala.reflect.internal interface, + // remove duplication here, and consolidate reflect.internal.{ReporterImpl & ReporterImpl} + class Severity(val id: Int)(name: String) { var count: Int = 0 ; override def toString = name} + object INFO extends Severity(0)("INFO") + object WARNING extends Severity(1)("WARNING") + // reason for copy/paste: this is used by partest (must be a val, not an object) + // TODO: use count(ERROR) in scala.tools.partest.nest.DirectCompiler#errorCount, rather than ERROR.count + lazy val ERROR = new Severity(2)("ERROR") + + def count(severity: Severity): Int = severity.count + def resetCount(severity: Severity): Unit = severity.count = 0 } diff --git a/src/reflect/scala/reflect/internal/Reporting.scala b/src/reflect/scala/reflect/internal/Reporting.scala index e88e76575064..baeed1357df4 100644 --- a/src/reflect/scala/reflect/internal/Reporting.scala +++ b/src/reflect/scala/reflect/internal/Reporting.scala @@ -7,11 +7,20 @@ package scala package reflect package internal +/** Provides delegates to the reporter doing the actual work. + * All forwarding methods should be marked final, + * but some subclasses out of our reach stil override them. + */ trait Reporting { self : Positions => + def reporter: Reporter + + @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2") def inform(msg: String): Unit = inform(NoPosition, msg) + @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2") def warning(msg: String): Unit = warning(NoPosition, msg) // globalError(msg: String) used to abort -- not sure that was a good idea, so I made it more regular // (couldn't find any uses that relied on old behavior) + @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2") def globalError(msg: String): Unit = globalError(NoPosition, msg) def abort(msg: String): Nothing = { @@ -21,12 +30,60 @@ trait Reporting { self : Positions => throw new FatalError(augmented) } - def inform(pos: Position, msg: String) = Console.out.println(msg) - def warning(pos: Position, msg: String) = Console.err.println(msg) - def globalError(pos: Position, msg: String) = Console.err.println(msg) + @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2") + def inform(pos: Position, msg: String) = reporter.echo(pos, msg) + @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2") + def warning(pos: Position, msg: String) = reporter.warning(pos, msg) + @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2") + def globalError(pos: Position, msg: String) = reporter.error(pos, msg) def deprecationWarning(pos: Position, msg: String): Unit = warning(msg) /** Overridden when we know more about what was happening during a failure. */ def supplementErrorMessage(msg: String): String = msg -} \ No newline at end of file +} + +import util.Position + +/** Report information, warnings and errors. + * + * This describes the (future) external interface for issuing information, warnings and errors. + * Currently, scala.tools.nsc.Reporter is used by sbt/ide/partest. + */ +abstract class Reporter { + protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit + + def echo(pos: Position, msg: String): Unit = info0(pos, msg, INFO, force = true) + def warning(pos: Position, msg: String): Unit = info0(pos, msg, WARNING, force = false) + def error(pos: Position, msg: String): Unit = info0(pos, msg, ERROR, force = false) + + type Severity + val INFO: Severity + val WARNING: Severity + val ERROR: Severity + + def count(severity: Severity): Int + def resetCount(severity: Severity): Unit + + def hasErrors: Boolean = count(ERROR) > 0 + def hasWarnings: Boolean = count(WARNING) > 0 + + def reset(): Unit = { + resetCount(INFO) + resetCount(WARNING) + resetCount(ERROR) + } + + def flush(): Unit = { } +} + +// TODO: move into superclass once partest cuts tie on Severity +abstract class ReporterImpl extends Reporter { + class Severity(val id: Int)(name: String) { var count: Int = 0 ; override def toString = name} + object INFO extends Severity(0)("INFO") + object WARNING extends Severity(1)("WARNING") + object ERROR extends Severity(2)("ERROR") + + def count(severity: Severity): Int = severity.count + def resetCount(severity: Severity): Unit = severity.count = 0 +} diff --git a/src/reflect/scala/reflect/runtime/JavaUniverse.scala b/src/reflect/scala/reflect/runtime/JavaUniverse.scala index b5446694ed10..d846ef2cdd75 100644 --- a/src/reflect/scala/reflect/runtime/JavaUniverse.scala +++ b/src/reflect/scala/reflect/runtime/JavaUniverse.scala @@ -14,15 +14,19 @@ import scala.reflect.api.{TreeCreator, TypeCreator, Universe} * @contentDiagram hideNodes "*Api" "*Extractor" */ class JavaUniverse extends InternalSymbolTable with JavaUniverseForce with ReflectSetup with RuntimeSymbolTable { self => - - override def inform(msg: String): Unit = log(msg) def picklerPhase = SomePhase def erasurePhase = SomePhase lazy val settings = new Settings - private val isLogging = sys.props contains "scala.debug.reflect" + private val isLogging = sys.props contains "scala.debug.reflect" def log(msg: => AnyRef): Unit = if (isLogging) Console.err.println("[reflect] " + msg) + // TODO: why put output under isLogging? Calls to inform are already conditional on debug/verbose/... + import scala.reflect.internal.{Reporter, ReporterImpl} + override def reporter: Reporter = new ReporterImpl { + protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit = log(msg) + } + type TreeCopier = InternalTreeCopierOps implicit val TreeCopierTag: ClassTag[TreeCopier] = ClassTag[TreeCopier](classOf[TreeCopier]) def newStrictTreeCopier: TreeCopier = new StrictTreeCopier diff --git a/test/junit/scala/tools/nsc/symtab/SymbolTableForUnitTesting.scala b/test/junit/scala/tools/nsc/symtab/SymbolTableForUnitTesting.scala index 25d8c4667f51..6b87a99e6fbb 100644 --- a/test/junit/scala/tools/nsc/symtab/SymbolTableForUnitTesting.scala +++ b/test/junit/scala/tools/nsc/symtab/SymbolTableForUnitTesting.scala @@ -72,6 +72,11 @@ class SymbolTableForUnitTesting extends SymbolTable { def picklerPhase: scala.reflect.internal.Phase = SomePhase def erasurePhase: scala.reflect.internal.Phase = SomePhase + // Members declared in scala.reflect.internal.Reporting + def reporter = new scala.reflect.internal.ReporterImpl { + protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit = println(msg) + } + // Members declared in scala.reflect.internal.SymbolTable def currentRunId: Int = 1 def log(msg: => AnyRef): Unit = println(msg) From e08735380e8cba8f4b7230f5615e528782a0111a Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 10 Jun 2014 12:32:06 +0200 Subject: [PATCH 360/826] Track symbol that caused a deprecation warning. So that we can filter deprecations based on defining package. Configurable error reporting will support a rule like: "In compilation unit X, escalate deprecation warnings that result from accessing members in package P that have been deprecated since version V. Report an error instead of a warning for those." TODO: remove deprecationWarning overload that doesn't take a `Symbol`? (Replace by a default value of `NoSymbol` for the deprecated symbol arg?) --- .../scala/tools/nsc/CompilationUnits.scala | 2 ++ src/compiler/scala/tools/nsc/Reporting.scala | 4 ++++ .../patmat/ScalacPatternExpanders.scala | 6 ++++-- .../tools/nsc/typechecker/Adaptations.scala | 2 +- .../tools/nsc/typechecker/NamesDefaults.scala | 4 ++-- .../scala/tools/nsc/typechecker/RefChecks.scala | 14 ++++++-------- .../scala/tools/nsc/typechecker/Typers.scala | 17 ++++++++--------- .../scala/reflect/internal/Reporting.scala | 3 +++ 8 files changed, 30 insertions(+), 22 deletions(-) diff --git a/src/compiler/scala/tools/nsc/CompilationUnits.scala b/src/compiler/scala/tools/nsc/CompilationUnits.scala index ae1b94dfa135..b9e745f1761c 100644 --- a/src/compiler/scala/tools/nsc/CompilationUnits.scala +++ b/src/compiler/scala/tools/nsc/CompilationUnits.scala @@ -132,8 +132,10 @@ trait CompilationUnits { global: Global => def warning(pos: Position, msg: String): Unit = reporter.warning(pos, msg) def deprecationWarning(pos: Position, msg: String): Unit = reporting.deprecationWarning(pos, msg) + def deprecationWarning(pos: Position, sym: Symbol, msg: String): Unit = reporting.deprecationWarning(pos, sym, msg) def uncheckedWarning(pos: Position, msg: String): Unit = reporting.uncheckedWarning(pos, msg) def inlinerWarning(pos: Position, msg: String): Unit = reporting.inlinerWarning(pos, msg) + def featureWarning(pos: Position, featureName: String, featureDesc: String, featureTrait: Symbol, construct: => String = "", required: Boolean): Unit = reporting.featureWarning(pos, featureName, featureDesc, featureTrait, construct, required) diff --git a/src/compiler/scala/tools/nsc/Reporting.scala b/src/compiler/scala/tools/nsc/Reporting.scala index a8fd3bec763d..1b5a77823530 100644 --- a/src/compiler/scala/tools/nsc/Reporting.scala +++ b/src/compiler/scala/tools/nsc/Reporting.scala @@ -61,6 +61,7 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w private val _inlinerWarnings = new ConditionalWarning("inliner", settings.YinlinerWarnings) private val _allConditionalWarnings = List(_deprecationWarnings, _uncheckedWarnings, _featureWarnings, _inlinerWarnings) + // TODO: remove in favor of the overload that takes a Symbol, give that argument a default (NoSymbol) def deprecationWarning(pos: Position, msg: String): Unit = _deprecationWarnings.warn(pos, msg) def uncheckedWarning(pos: Position, msg: String): Unit = _uncheckedWarnings.warn(pos, msg) def featureWarning(pos: Position, msg: String): Unit = _featureWarnings.warn(pos, msg) @@ -73,6 +74,9 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w def allConditionalWarnings = _allConditionalWarnings flatMap (_.warnings) + // behold! the symbol that caused the deprecation warning (may not be deprecated itself) + def deprecationWarning(pos: Position, sym: Symbol, msg: String): Unit = _deprecationWarnings.warn(pos, msg) + private[this] var reportedFeature = Set[Symbol]() def featureWarning(pos: Position, featureName: String, featureDesc: String, featureTrait: Symbol, construct: => String = "", required: Boolean): Unit = { val req = if (required) "needs to" else "should" diff --git a/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala b/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala index d10eff1d8d19..c19786d5e7e4 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala @@ -139,8 +139,10 @@ trait ScalacPatternExpanders { def acceptMessage = if (extractor.isErroneous) "" else s" to hold ${extractor.offeringString}" val requiresTupling = isUnapply && patterns.totalArity == 1 && productArity > 1 - if (requiresTupling && effectivePatternArity(args) == 1) - currentUnit.deprecationWarning(sel.pos, s"${sel.symbol.owner} expects $productArity patterns$acceptMessage but crushing into $productArity-tuple to fit single pattern (SI-6675)") + if (requiresTupling && effectivePatternArity(args) == 1) { + val sym = sel.symbol.owner + currentUnit.deprecationWarning(sel.pos, sym, s"${sym} expects $productArity patterns$acceptMessage but crushing into $productArity-tuple to fit single pattern (SI-6675)") + } val normalizedExtractor = if (requiresTupling) tupleExtractor(extractor) else extractor validateAligned(fn, Aligned(patterns, normalizedExtractor)) diff --git a/src/compiler/scala/tools/nsc/typechecker/Adaptations.scala b/src/compiler/scala/tools/nsc/typechecker/Adaptations.scala index 1e544e54f632..6e99b9bd4c7f 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Adaptations.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Adaptations.scala @@ -77,7 +77,7 @@ trait Adaptations { val msg = "Adaptation of argument list by inserting () has been deprecated: " + ( if (isLeakyTarget) "leaky (Object-receiving) target makes this especially dangerous." else "this is unlikely to be what you want.") - context.unit.deprecationWarning(t.pos, adaptWarningMessage(msg)) + context.unit.deprecationWarning(t.pos, t.symbol, adaptWarningMessage(msg)) } } else if (settings.warnAdaptedArgs) context.warning(t.pos, adaptWarningMessage(s"Adapting argument list by creating a ${args.size}-tuple: this may not be what you want.")) diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala index 284ab2f6f95a..65f33952d32a 100644 --- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala +++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala @@ -536,8 +536,8 @@ trait NamesDefaults { self: Analyzer => def matchesName(param: Symbol) = !param.isSynthetic && ( (param.name == name) || (param.deprecatedParamName match { case Some(`name`) => - context0.unit.deprecationWarning(arg.pos, - "the parameter name "+ name +" has been deprecated. Use "+ param.name +" instead.") + context0.unit.deprecationWarning(arg.pos, param, + s"the parameter name $name has been deprecated. Use ${param.name} instead.") true case _ => false }) diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index 4540017b62b0..0d79637c88ff 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -546,7 +546,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans if (other.hasDeprecatedOverridingAnnotation) { val suffix = other.deprecatedOverridingMessage map (": " + _) getOrElse "" val msg = s"overriding ${other.fullLocationString} is deprecated$suffix" - unit.deprecationWarning(member.pos, msg) + unit.deprecationWarning(member.pos, other, msg) } } } @@ -1287,11 +1287,9 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans private def checkUndesiredProperties(sym: Symbol, pos: Position) { // If symbol is deprecated, and the point of reference is not enclosed // in either a deprecated member or a scala bridge method, issue a warning. - if (sym.isDeprecated && !currentOwner.ownerChain.exists(x => x.isDeprecated || x.hasBridgeAnnotation)) { - unit.deprecationWarning(pos, "%s%s is deprecated%s".format( - sym, sym.locationString, sym.deprecationMessage map (": " + _) getOrElse "") - ) - } + if (sym.isDeprecated && !currentOwner.ownerChain.exists(x => x.isDeprecated || x.hasBridgeAnnotation)) + unit.deprecationWarning(pos, sym, s"${sym}${sym.locationString} is deprecated${sym.deprecationMessage map (": " + _) getOrElse ""}") + // Similar to deprecation: check if the symbol is marked with @migration // indicating it has changed semantics between versions. if (sym.hasMigrationAnnotation && settings.Xmigration.value != NoScalaVersion) { @@ -1409,8 +1407,8 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans if(!concrOvers.isEmpty) unit.deprecationWarning( tree.pos, - symbol.toString + " overrides concrete, non-deprecated symbol(s):" + - concrOvers.map(_.name.decode).mkString(" ", ", ", "")) + symbol, + s"${symbol.toString} overrides concrete, non-deprecated symbol(s): ${concrOvers.map(_.name.decode).mkString(", ")}") } } private def isRepeatedParamArg(tree: Tree) = currentApplication match { diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 059b58c94338..3c215ea10b69 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -941,10 +941,9 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper } def adaptConstant(value: Constant): Tree = { val sym = tree.symbol - if (sym != null && sym.isDeprecated) { - val msg = sym.toString + sym.locationString + " is deprecated: " + sym.deprecationMessage.getOrElse("") - unit.deprecationWarning(tree.pos, msg) - } + if (sym != null && sym.isDeprecated) + unit.deprecationWarning(tree.pos, sym, s"${sym.toString}${sym.locationString} is deprecated: ${sym.deprecationMessage.getOrElse("")}") + treeCopy.Literal(tree, value) } @@ -1676,7 +1675,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper if (!isPastTyper && psym.hasDeprecatedInheritanceAnnotation && !sameSourceFile) { val suffix = psym.deprecatedInheritanceMessage map (": " + _) getOrElse "" val msg = s"inheritance from ${psym.fullLocationString} is deprecated$suffix" - unit.deprecationWarning(parent.pos, msg) + unit.deprecationWarning(parent.pos, psym, msg) } if (psym.isSealed && !phase.erasedTypes) @@ -3666,7 +3665,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper } if (annType.typeSymbol == DeprecatedAttr && argss.flatten.size < 2) - unit.deprecationWarning(ann.pos, "@deprecated now takes two arguments; see the scaladoc.") + unit.deprecationWarning(ann.pos, DeprecatedAttr, "@deprecated now takes two arguments; see the scaladoc.") if ((typedAnn.tpe == null) || typedAnn.tpe.isErroneous) ErroneousAnnotation else annInfo(typedAnn) @@ -4698,10 +4697,10 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper // temporarily use `filter` as an alternative for `withFilter` def tryWithFilterAndFilter(tree: Select, qual: Tree): Tree = { - def warn() = unit.deprecationWarning(tree.pos, s"`withFilter' method does not yet exist on ${qual.tpe.widen}, using `filter' method instead") + def warn(sym: Symbol) = unit.deprecationWarning(tree.pos, sym, s"`withFilter' method does not yet exist on ${qual.tpe.widen}, using `filter' method instead") silent(_ => typedSelect(tree, qual, nme.withFilter)) orElse { _ => silent(_ => typed1(Select(qual, nme.filter) setPos tree.pos, mode, pt)) match { - case SilentResultValue(res) => warn() ; res + case SilentResultValue(res) => warn(res.symbol) ; res case SilentTypeError(err) => WithFilterError(tree, err) } } @@ -5482,7 +5481,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper } def reportWarning(inferredType: Type) = { val explanation = s"inference of $inferredType from macro impl's c.Expr[$inferredType] is deprecated and is going to stop working in 2.12" - unit.deprecationWarning(ddef.pos, s"$commonMessage ($explanation)") + unit.deprecationWarning(ddef.pos, ddef.symbol, s"$commonMessage ($explanation)") } computeMacroDefTypeFromMacroImplRef(ddef, rhs1) match { case ErrorType => ErrorType diff --git a/src/reflect/scala/reflect/internal/Reporting.scala b/src/reflect/scala/reflect/internal/Reporting.scala index baeed1357df4..0670e9bd8e50 100644 --- a/src/reflect/scala/reflect/internal/Reporting.scala +++ b/src/reflect/scala/reflect/internal/Reporting.scala @@ -10,6 +10,9 @@ package internal /** Provides delegates to the reporter doing the actual work. * All forwarding methods should be marked final, * but some subclasses out of our reach stil override them. + * + * Eventually, this interface should be reduced to one method: `reporter`, + * and clients should indirect themselves (reduce duplication of forwarders). */ trait Reporting { self : Positions => def reporter: Reporter From 59db57f5ac26609186d6338d2d7cfaf1281b78ab Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Mon, 23 Jun 2014 17:49:59 +0200 Subject: [PATCH 361/826] Route type checker reporting through context Continue the work started in SI-8450 (no "implicit numeric widening" warning in silent mode), which was caused by going straight to the reporter instead of using the context for type error reporting (which buffers in silent mode). Ideally, this mistake should not be possible: typer should change the current reporter to buffer where appropriate. --- .../tools/nsc/typechecker/Adaptations.scala | 2 +- .../tools/nsc/typechecker/Contexts.scala | 8 +++ .../tools/nsc/typechecker/NamesDefaults.scala | 2 +- .../scala/tools/nsc/typechecker/Typers.scala | 52 +++++++++---------- 4 files changed, 36 insertions(+), 28 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Adaptations.scala b/src/compiler/scala/tools/nsc/typechecker/Adaptations.scala index 6e99b9bd4c7f..37c39c07beaa 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Adaptations.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Adaptations.scala @@ -77,7 +77,7 @@ trait Adaptations { val msg = "Adaptation of argument list by inserting () has been deprecated: " + ( if (isLeakyTarget) "leaky (Object-receiving) target makes this especially dangerous." else "this is unlikely to be what you want.") - context.unit.deprecationWarning(t.pos, t.symbol, adaptWarningMessage(msg)) + context.deprecationWarning(t.pos, t.symbol, adaptWarningMessage(msg)) } } else if (settings.warnAdaptedArgs) context.warning(t.pos, adaptWarningMessage(s"Adapting argument list by creating a ${args.size}-tuple: this may not be what you want.")) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 8e1ceffecd10..03890f30f645 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -593,6 +593,14 @@ trait Contexts { self: Analyzer => else if (bufferErrors) reportBuffer += (pos -> msg) } + def deprecationWarning(pos: Position, sym: Symbol, msg: String): Unit = + currentRun.reporting.deprecationWarning(pos, sym, msg) + + def featureWarning(pos: Position, featureName: String, featureDesc: String, featureTrait: Symbol, construct: => String = "", required: Boolean): Unit = + currentRun.reporting.featureWarning(pos, featureName, featureDesc, featureTrait, construct, required) + + def echo(pos: Position, msg: String): Unit = reporter.echo(pos, msg) + // nextOuter determines which context is searched next for implicits // (after `this`, which contributes `newImplicits` below.) In // most cases, it is simply the outer context: if we're owned by diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala index 65f33952d32a..43902d1c65b9 100644 --- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala +++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala @@ -536,7 +536,7 @@ trait NamesDefaults { self: Analyzer => def matchesName(param: Symbol) = !param.isSynthetic && ( (param.name == name) || (param.deprecatedParamName match { case Some(`name`) => - context0.unit.deprecationWarning(arg.pos, param, + context0.deprecationWarning(arg.pos, param, s"the parameter name $name has been deprecated. Use ${param.name} instead.") true case _ => false diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 3c215ea10b69..349bad555a11 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -746,7 +746,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper if (!OK) { val Some(AnnotationInfo(_, List(Literal(Constant(featureDesc: String)), Literal(Constant(required: Boolean))), _)) = featureTrait getAnnotation LanguageFeatureAnnot - unit.featureWarning(pos, featureName, featureDesc, featureTrait, construct, required) + context.featureWarning(pos, featureName, featureDesc, featureTrait, construct, required) } OK } @@ -942,7 +942,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper def adaptConstant(value: Constant): Tree = { val sym = tree.symbol if (sym != null && sym.isDeprecated) - unit.deprecationWarning(tree.pos, sym, s"${sym.toString}${sym.locationString} is deprecated: ${sym.deprecationMessage.getOrElse("")}") + context.deprecationWarning(tree.pos, sym, s"${sym.toString}${sym.locationString} is deprecated: ${sym.deprecationMessage.getOrElse("")}") treeCopy.Literal(tree, value) } @@ -1051,7 +1051,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper case coercion => def msg = "inferred view from " + tree.tpe + " to " + pt + " = " + coercion + ":" + coercion.tpe if (settings.logImplicitConv) - unit.echo(tree.pos, msg) + context.echo(tree.pos, msg) debuglog(msg) val silentContext = context.makeImplicit(context.ambiguousErrors) @@ -1211,7 +1211,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper case EmptyTree => qual case coercion => if (settings.logImplicitConv) - unit.echo(qual.pos, + context.echo(qual.pos, "applied implicit conversion from %s to %s = %s".format( qual.tpe, searchTemplate, coercion.symbol.defString)) @@ -1276,7 +1276,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper private def validateNoCaseAncestor(clazz: Symbol) = { if (!phase.erasedTypes) { for (ancestor <- clazz.ancestors find (_.isCase)) { - unit.error(clazz.pos, ( + context.error(clazz.pos, ( "case %s has case ancestor %s, but case-to-case inheritance is prohibited."+ " To overcome this limitation, use extractors to pattern match on non-leaf nodes." ).format(clazz, ancestor.fullName)) @@ -1293,7 +1293,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper val isValueClass = !clazz.isTrait def where = if (isValueClass) "value class" else "universal trait extending from class Any" def implRestriction(tree: Tree, what: String) = - unit.error(tree.pos, s"implementation restriction: $what is not allowed in $where" + + context.error(tree.pos, s"implementation restriction: $what is not allowed in $where" + "\nThis restriction is planned to be removed in subsequent releases.") /** * Deeply traverses the tree in search of constructs that are not allowed @@ -1322,7 +1322,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper } } for (stat <- body) { - def notAllowed(what: String) = unit.error(stat.pos, s"$what is not allowed in $where") + def notAllowed(what: String) = context.error(stat.pos, s"$what is not allowed in $where") stat match { // see https://issues.scala-lang.org/browse/SI-6444 // see https://issues.scala-lang.org/browse/SI-6463 @@ -1350,9 +1350,9 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper private def validateDerivedValueClass(clazz: Symbol, body: List[Tree]) = { if (clazz.isTrait) - unit.error(clazz.pos, "only classes (not traits) are allowed to extend AnyVal") + context.error(clazz.pos, "only classes (not traits) are allowed to extend AnyVal") if (!clazz.isStatic) - unit.error(clazz.pos, "value class may not be a "+ + context.error(clazz.pos, "value class may not be a "+ (if (clazz.owner.isTerm) "local class" else "member of another class")) if (!clazz.isPrimitiveValueClass) { clazz.primaryConstructor.paramss match { @@ -1360,26 +1360,26 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper val decls = clazz.info.decls val paramAccessor = clazz.constrParamAccessors.head if (paramAccessor.isMutable) - unit.error(paramAccessor.pos, "value class parameter must not be a var") + context.error(paramAccessor.pos, "value class parameter must not be a var") val accessor = decls.toList.find(x => x.isMethod && x.accessedOrSelf == paramAccessor) accessor match { case None => - unit.error(paramAccessor.pos, "value class parameter must be a val and not be private[this]") + context.error(paramAccessor.pos, "value class parameter must be a val and not be private[this]") case Some(acc) if acc.isProtectedLocal => - unit.error(paramAccessor.pos, "value class parameter must not be protected[this]") + context.error(paramAccessor.pos, "value class parameter must not be protected[this]") case Some(acc) => if (acc.tpe.typeSymbol.isDerivedValueClass) - unit.error(acc.pos, "value class may not wrap another user-defined value class") + context.error(acc.pos, "value class may not wrap another user-defined value class") checkEphemeral(clazz, body filterNot (stat => stat.symbol != null && stat.symbol.accessedOrSelf == paramAccessor)) } case _ => - unit.error(clazz.pos, "value class needs to have exactly one val parameter") + context.error(clazz.pos, "value class needs to have exactly one val parameter") } } for (tparam <- clazz.typeParams) if (tparam hasAnnotation definitions.SpecializedClass) - unit.error(tparam.pos, "type parameter of value class may not be specialized") + context.error(tparam.pos, "type parameter of value class may not be specialized") } /** Typechecks a parent type reference. @@ -1675,7 +1675,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper if (!isPastTyper && psym.hasDeprecatedInheritanceAnnotation && !sameSourceFile) { val suffix = psym.deprecatedInheritanceMessage map (": " + _) getOrElse "" val msg = s"inheritance from ${psym.fullLocationString} is deprecated$suffix" - unit.deprecationWarning(parent.pos, psym, msg) + context.deprecationWarning(parent.pos, psym, msg) } if (psym.isSealed && !phase.erasedTypes) @@ -1742,7 +1742,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper if ((clazz isNonBottomSubClass ClassfileAnnotationClass) && (clazz != ClassfileAnnotationClass)) { if (!clazz.owner.isPackageClass) - unit.error(clazz.pos, "inner classes cannot be classfile annotations") + context.error(clazz.pos, "inner classes cannot be classfile annotations") else restrictionWarning(cdef.pos, unit, """|subclassing Classfile does not |make your annotation visible at runtime. If that is what @@ -1797,7 +1797,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper private def ensurePredefParentsAreInSameSourceFile(template: Template) = { val parentSyms = template.parents map (_.symbol) filterNot (_ == AnyRefClass) if (parentSyms exists (_.associatedFile != PredefModule.associatedFile)) - unit.error(template.pos, s"All parents of Predef must be defined in ${PredefModule.associatedFile}.") + context.error(template.pos, s"All parents of Predef must be defined in ${PredefModule.associatedFile}.") } /** In order to override this in the TreeCheckers Typer so synthetics aren't re-added * all the time, it is exposed here the module/class typing methods go through it. @@ -1868,7 +1868,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper ConstrArgsInParentOfTraitError(parents1.head, clazz) if ((clazz isSubClass ClassfileAnnotationClass) && !clazz.isTopLevel) - unit.error(clazz.pos, "inner classes cannot be classfile annotations") + context.error(clazz.pos, "inner classes cannot be classfile annotations") if (!phase.erasedTypes && !clazz.info.resultType.isError) // @S: prevent crash for duplicated type members checkFinitary(clazz.info.resultType.asInstanceOf[ClassInfoType]) @@ -1896,7 +1896,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper if (clazz.isTrait) { for (decl <- clazz.info.decls if decl.isTerm && decl.isEarlyInitialized) { - unit.warning(decl.pos, "Implementation restriction: early definitions in traits are not initialized before the super class is initialized.") + context.warning(decl.pos, "Implementation restriction: early definitions in traits are not initialized before the super class is initialized.") } } @@ -2084,7 +2084,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper case xs => xs.map(_.nameString).mkString(" (of ", " with ", ")") } def fail(pos: Position, msg: String): Boolean = { - unit.error(pos, msg) + context.error(pos, msg) false } /* Have to examine all parameters in all lists. @@ -3665,7 +3665,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper } if (annType.typeSymbol == DeprecatedAttr && argss.flatten.size < 2) - unit.deprecationWarning(ann.pos, DeprecatedAttr, "@deprecated now takes two arguments; see the scaladoc.") + context.deprecationWarning(ann.pos, DeprecatedAttr, "@deprecated now takes two arguments; see the scaladoc.") if ((typedAnn.tpe == null) || typedAnn.tpe.isErroneous) ErroneousAnnotation else annInfo(typedAnn) @@ -4239,7 +4239,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper // it is non-Unit) so we have to retype it. Fortunately it won't come up much // unless the warning is legitimate. if (typed(expr).tpe.typeSymbol != UnitClass) - unit.warning(tree.pos, "enclosing method " + name + " has result type Unit: return value discarded") + context.warning(tree.pos, "enclosing method " + name + " has result type Unit: return value discarded") } val res = treeCopy.Return(tree, checkDead(expr1)).setSymbol(enclMethod.owner) val tp = pluginsTypedReturn(NothingTpe, this, res, restpt.tpe) @@ -4697,7 +4697,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper // temporarily use `filter` as an alternative for `withFilter` def tryWithFilterAndFilter(tree: Select, qual: Tree): Tree = { - def warn(sym: Symbol) = unit.deprecationWarning(tree.pos, sym, s"`withFilter' method does not yet exist on ${qual.tpe.widen}, using `filter' method instead") + def warn(sym: Symbol) = context.deprecationWarning(tree.pos, sym, s"`withFilter' method does not yet exist on ${qual.tpe.widen}, using `filter' method instead") silent(_ => typedSelect(tree, qual, nme.withFilter)) orElse { _ => silent(_ => typed1(Select(qual, nme.filter) setPos tree.pos, mode, pt)) match { case SilentResultValue(res) => warn(res.symbol) ; res @@ -5477,11 +5477,11 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper val commonMessage = "macro defs must have explicitly specified return types" def reportFailure() = { ddef.symbol.setFlag(IS_ERROR) - unit.error(ddef.pos, commonMessage) + context.error(ddef.pos, commonMessage) } def reportWarning(inferredType: Type) = { val explanation = s"inference of $inferredType from macro impl's c.Expr[$inferredType] is deprecated and is going to stop working in 2.12" - unit.deprecationWarning(ddef.pos, ddef.symbol, s"$commonMessage ($explanation)") + context.deprecationWarning(ddef.pos, ddef.symbol, s"$commonMessage ($explanation)") } computeMacroDefTypeFromMacroImplRef(ddef, rhs1) match { case ErrorType => ErrorType From b7242013830510776fbb93bbf0e883532133030c Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Mon, 23 Jun 2014 17:50:19 +0200 Subject: [PATCH 362/826] Rip out reporting indirection from CompilationUnit Inline the forwarders from CompilationUnit, which should not affect behavior. Since all forwarders lead to global.reporter, don't first navigate to a compilation unit, only to then forward back to global.reporter. The cleanup in the previous commits revealed a ton of confusion regarding how to report an error. This was a mechanical search/replace, which has low potential for messing things up, since the list of available methods are disjoint between `reporter` and `currentRun.reporting`. The changes involving `typer.context` were done previously. Essentially, there are three ways to report: - via typer.context, so that reporting can be silenced (buffered) - via global.currentRun.reporting, which summarizes (e.g., deprecation) - via global.reporter, which is (mostly) stateless and straightforward. Ideally, these should all just go through `global.currentRun.reporting`, with the typing context changing that reporter to buffer where necessary. After the refactor, these are the ways in which we report (outside of typer): - reporter.comment - reporter.echo - reporter.error - reporter.warning - currentRun.reporting.deprecationWarning - currentRun.reporting.incompleteHandled - currentRun.reporting.incompleteInputError - currentRun.reporting.inlinerWarning - currentRun.reporting.uncheckedWarning Before: - c.cunit.error - c.enclosingUnit.deprecationWarning - context.unit.error - context.unit.warning - csymCompUnit.warning - cunit.error - cunit.warning - currentClass.cunit.warning - currentIClazz.cunit.inlinerWarning - currentRun.currentUnit.error - currentRun.reporting - currentUnit.deprecationWarning - currentUnit.error - currentUnit.warning - getContext.unit.warning - getCurrentCUnit.error - global.currentUnit.uncheckedWarning - global.currentUnit.warning - global.reporter - icls.cunit.warning - item.cunit.warning - reporter.comment - reporter.echo - reporter.error - reporter.warning - reporting.deprecationWarning - reporting.incompleteHandled - reporting.incompleteInputError - reporting.inlinerWarning - reporting.uncheckedWarning - typer.context.unit.warning - unit.deprecationWarning - unit.echo - unit.error - unit.incompleteHandled - unit.incompleteInputError - unit.uncheckedWarning - unit.warning - v1.cunit.warning All these methods ended up calling a method on `global.reporter` or on `global.currentRun.reporting` (their interfaces are disjoint). Also clean up `TypeDiagnostics`: inline nearly-single-use private methods. --- .../reflect/macros/contexts/Parsers.scala | 20 ++--- .../scala/tools/nsc/CompilationUnits.scala | 25 +------ src/compiler/scala/tools/nsc/Global.scala | 4 +- .../scala/tools/nsc/ast/parser/Parsers.scala | 10 +-- .../scala/tools/nsc/ast/parser/Scanners.scala | 6 +- .../tools/nsc/ast/parser/SyntaxAnalyzer.scala | 2 +- .../tools/nsc/backend/icode/GenICode.scala | 2 +- .../nsc/backend/jvm/BCodeBodyBuilder.scala | 4 +- .../tools/nsc/backend/jvm/BCodeHelpers.scala | 4 +- .../nsc/backend/jvm/BCodeSkelBuilder.scala | 2 +- .../scala/tools/nsc/backend/jvm/GenASM.scala | 10 +-- .../tools/nsc/backend/jvm/GenBCode.scala | 2 +- .../tools/nsc/backend/jvm/GenJVMASM.scala | 2 +- .../backend/opt/InlineExceptionHandlers.scala | 4 +- .../tools/nsc/backend/opt/Inliners.scala | 2 +- .../scala/tools/nsc/javac/JavaParsers.scala | 6 +- .../scala/tools/nsc/javac/JavaScanners.scala | 6 +- .../tools/nsc/symtab/classfile/Pickler.scala | 2 +- .../scala/tools/nsc/transform/CleanUp.scala | 8 +- .../tools/nsc/transform/Constructors.scala | 4 +- .../scala/tools/nsc/transform/Erasure.scala | 10 +-- .../tools/nsc/transform/ExplicitOuter.scala | 2 +- .../nsc/transform/ExtensionMethods.scala | 2 +- .../tools/nsc/transform/LambdaLift.scala | 2 +- .../scala/tools/nsc/transform/Mixin.scala | 2 +- .../scala/tools/nsc/transform/TailCalls.scala | 6 +- .../scala/tools/nsc/transform/UnCurry.scala | 10 +-- .../nsc/transform/patmat/MatchAnalysis.scala | 4 +- .../transform/patmat/MatchOptimization.scala | 2 +- .../transform/patmat/MatchTranslation.scala | 2 +- .../transform/patmat/MatchTreeMaking.scala | 2 +- .../nsc/transform/patmat/MatchWarnings.scala | 4 +- .../transform/patmat/PatternMatching.scala | 6 +- .../patmat/ScalacPatternExpanders.scala | 6 +- .../tools/nsc/typechecker/Checkable.scala | 6 +- .../tools/nsc/typechecker/Contexts.scala | 10 +-- .../scala/tools/nsc/typechecker/Infer.scala | 2 +- .../scala/tools/nsc/typechecker/Namers.scala | 6 +- .../tools/nsc/typechecker/RefChecks.scala | 74 +++++++++---------- .../nsc/typechecker/SuperAccessors.scala | 12 +-- .../tools/nsc/typechecker/TreeCheckers.scala | 4 +- .../nsc/typechecker/TypeDiagnostics.scala | 20 ++--- .../tools/reflect/FormatInterpolator.scala | 2 +- .../tools/nsc/doc/ScaladocAnalyzer.scala | 6 +- 44 files changed, 152 insertions(+), 175 deletions(-) diff --git a/src/compiler/scala/reflect/macros/contexts/Parsers.scala b/src/compiler/scala/reflect/macros/contexts/Parsers.scala index 9975bd22a01e..f4584f36277a 100644 --- a/src/compiler/scala/reflect/macros/contexts/Parsers.scala +++ b/src/compiler/scala/reflect/macros/contexts/Parsers.scala @@ -9,15 +9,15 @@ trait Parsers { def parse(code: String) = { val sreporter = new StoreReporter() - val unit = new CompilationUnit(newSourceFile(code, "")) { - override def reporter = sreporter - override def reporting = new PerRunReporting { override def reporter = sreporter } - } - val parser = newUnitParser(unit) - val tree = gen.mkTreeOrBlock(parser.parseStatsOrPackages()) - sreporter.infos.foreach { - case sreporter.Info(pos, msg, sreporter.ERROR) => throw ParseException(pos, msg) - } - tree + val oldReporter = global.reporter + try { + global.reporter = sreporter + val parser = newUnitParser(new CompilationUnit(newSourceFile(code, ""))) + val tree = gen.mkTreeOrBlock(parser.parseStatsOrPackages()) + sreporter.infos.foreach { + case sreporter.Info(pos, msg, sreporter.ERROR) => throw ParseException(pos, msg) + } + tree + } finally global.reporter = oldReporter } } \ No newline at end of file diff --git a/src/compiler/scala/tools/nsc/CompilationUnits.scala b/src/compiler/scala/tools/nsc/CompilationUnits.scala index b9e745f1761c..1ad206f51953 100644 --- a/src/compiler/scala/tools/nsc/CompilationUnits.scala +++ b/src/compiler/scala/tools/nsc/CompilationUnits.scala @@ -123,28 +123,9 @@ trait CompilationUnits { global: Global => */ val icode: LinkedHashSet[icodes.IClass] = new LinkedHashSet - // reporter and its forwarded methods - def reporter = global.reporter - def reporting = currentRun.reporting - - def echo(pos: Position, msg: String): Unit = reporter.echo(pos, msg) - def error(pos: Position, msg: String): Unit = reporter.error(pos, msg) - def warning(pos: Position, msg: String): Unit = reporter.warning(pos, msg) - - def deprecationWarning(pos: Position, msg: String): Unit = reporting.deprecationWarning(pos, msg) - def deprecationWarning(pos: Position, sym: Symbol, msg: String): Unit = reporting.deprecationWarning(pos, sym, msg) - def uncheckedWarning(pos: Position, msg: String): Unit = reporting.uncheckedWarning(pos, msg) - def inlinerWarning(pos: Position, msg: String): Unit = reporting.inlinerWarning(pos, msg) - - def featureWarning(pos: Position, featureName: String, featureDesc: String, featureTrait: Symbol, construct: => String = "", - required: Boolean): Unit = reporting.featureWarning(pos, featureName, featureDesc, featureTrait, construct, required) - - // repl - def incompleteHandled: Boolean = reporting.incompleteHandled - def incompleteInputError(pos: Position, msg:String): Unit = reporting.incompleteInputError(pos, msg) - - // used by the IDE -- TODO: don't use reporter to communicate comments from parser to IDE! - def comment(pos: Position, msg: String): Unit = reporter.comment(pos, msg) + // called by ScalaDocAnalyzer, overridden by the IDE (in Reporter) + // TODO: don't use reporter to communicate comments from parser to IDE! + final def comment(pos: Position, msg: String): Unit = reporter.comment(pos, msg) /** Is this about a .java source file? */ diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index daf69ffc3f03..a6fa3bf1dccd 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -1434,10 +1434,10 @@ class Global(var currentSettings: Settings, var reporter: Reporter) private def checkDeprecatedSettings(unit: CompilationUnit) { // issue warnings for any usage of deprecated settings settings.userSetSettings filter (_.isDeprecated) foreach { s => - unit.deprecationWarning(NoPosition, s.name + " is deprecated: " + s.deprecationMessage.get) + currentRun.reporting.deprecationWarning(NoPosition, s.name + " is deprecated: " + s.deprecationMessage.get) } if (settings.target.value.contains("jvm-1.5")) - unit.deprecationWarning(NoPosition, settings.target.name + ":" + settings.target.value + " is deprecated: use target for Java 1.6 or above.") + currentRun.reporting.deprecationWarning(NoPosition, settings.target.name + ":" + settings.target.value + " is deprecated: use target for Java 1.6 or above.") } /* An iterator returning all the units being compiled in this run */ diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index ffc45b21ea40..883fd31dbc99 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -205,11 +205,11 @@ self => override def newScanner() = new UnitScanner(unit, patches) override def warning(offset: Offset, msg: String) { - unit.warning(o2p(offset), msg) + reporter.warning(o2p(offset), msg) } override def deprecationWarning(offset: Offset, msg: String) { - unit.deprecationWarning(o2p(offset), msg) + currentRun.reporting.deprecationWarning(o2p(offset), msg) } private var smartParsing = false @@ -224,17 +224,17 @@ self => val syntaxErrors = new ListBuffer[(Int, String)] def showSyntaxErrors() = for ((offset, msg) <- syntaxErrors) - unit.error(o2p(offset), msg) + reporter.error(o2p(offset), msg) override def syntaxError(offset: Offset, msg: String) { if (smartParsing) syntaxErrors += ((offset, msg)) - else unit.error(o2p(offset), msg) + else reporter.error(o2p(offset), msg) } override def incompleteInputError(msg: String) { val offset = source.content.length - 1 if (smartParsing) syntaxErrors += ((offset, msg)) - else unit.incompleteInputError(o2p(offset), msg) + else currentRun.reporting.incompleteInputError(o2p(offset), msg) } /** parse unit. If there are inbalanced braces, diff --git a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala index e8d46704c32b..572497ac9010 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala @@ -1259,9 +1259,9 @@ trait Scanners extends ScannersCommon { class UnitScanner(val unit: CompilationUnit, patches: List[BracePatch]) extends SourceFileScanner(unit.source) { def this(unit: CompilationUnit) = this(unit, List()) - override def deprecationWarning(off: Offset, msg: String) = unit.deprecationWarning(unit.position(off), msg) - override def error (off: Offset, msg: String) = unit.error(unit.position(off), msg) - override def incompleteInputError(off: Offset, msg: String) = unit.incompleteInputError(unit.position(off), msg) + override def deprecationWarning(off: Offset, msg: String) = currentRun.reporting.deprecationWarning(unit.position(off), msg) + override def error (off: Offset, msg: String) = reporter.error(unit.position(off), msg) + override def incompleteInputError(off: Offset, msg: String) = currentRun.reporting.incompleteInputError(unit.position(off), msg) private var bracePatches: List[BracePatch] = patches diff --git a/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala b/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala index 3d8a7d2e556b..64b762696e37 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala @@ -83,7 +83,7 @@ abstract class SyntaxAnalyzer extends SubComponent with Parsers with MarkupParse private def initialUnitBody(unit: CompilationUnit): Tree = { if (unit.isJava) new JavaUnitParser(unit).parse() - else if (unit.incompleteHandled) newUnitParser(unit).parse() + else if (currentRun.reporting.incompleteHandled) newUnitParser(unit).parse() else newUnitParser(unit).smartParse() } diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala index 0ad3c2c76bbb..d9f56b47faf7 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala @@ -680,7 +680,7 @@ abstract class GenICode extends SubComponent { val dims = arr.dimensions var elemKind = arr.elementKind if (args.length > dims) - unit.error(tree.pos, "too many arguments for array constructor: found " + args.length + + reporter.error(tree.pos, "too many arguments for array constructor: found " + args.length + " but array has only " + dims + " dimension(s)") if (args.length != dims) for (i <- args.length until dims) elemKind = ARRAY(elemKind) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index bffa4bc51daf..4583462b711c 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -504,7 +504,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { case nextCleanup :: rest => if (saveReturnValue) { if (insideCleanupBlock) { - cunit.warning(r.pos, "Return statement found in finally-clause, discarding its return-value in favor of that of a more deeply nested return.") + reporter.warning(r.pos, "Return statement found in finally-clause, discarding its return-value in favor of that of a more deeply nested return.") bc drop returnType } else { // regarding return value, the protocol is: in place of a `return-stmt`, a sequence of `adapt, store, jump` are inserted. @@ -602,7 +602,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { var elemKind = arr.elementType val argsSize = args.length if (argsSize > dims) { - cunit.error(app.pos, s"too many arguments for array constructor: found ${args.length} but array has only $dims dimension(s)") + reporter.error(app.pos, s"too many arguments for array constructor: found ${args.length} but array has only $dims dimension(s)") } if (argsSize < dims) { /* In one step: diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala index 51bfdf002720..31a392ed5521 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala @@ -38,7 +38,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { outputDirectory(csym) } catch { case ex: Throwable => - cunit.error(cunit.body.pos, s"Couldn't create file for class $cName\n${ex.getMessage}") + reporter.error(cunit.body.pos, s"Couldn't create file for class $cName\n${ex.getMessage}") null } } @@ -141,7 +141,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { */ def apply(sym: Symbol, csymCompUnit: CompilationUnit): Boolean = { def fail(msg: String, pos: Position = sym.pos) = { - csymCompUnit.warning(sym.pos, + reporter.warning(sym.pos, sym.name + s" has a main method with parameter type Array[String], but ${sym.fullName('.')} will not be a runnable program.\n Reason: $msg" // TODO: make this next claim true, if possible diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala index effc68c5e317..8845ffa0cd5f 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala @@ -570,7 +570,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { if (params.size > MaximumJvmParameters) { // SI-7324 - cunit.error(methSymbol.pos, s"Platform restriction: a parameter list's length cannot exceed $MaximumJvmParameters.") + reporter.error(methSymbol.pos, s"Platform restriction: a parameter list's length cannot exceed $MaximumJvmParameters.") return } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala index 988c04f514f9..b0fb3069c125 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala @@ -113,7 +113,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { // Warn when classes will overwrite one another on case-insensitive systems. for ((_, v1 :: v2 :: _) <- sortedClasses groupBy (_.symbol.javaClassName.toString.toLowerCase)) { - v1.cunit.warning(v1.symbol.pos, + reporter.warning(v1.symbol.pos, s"Class ${v1.symbol.javaClassName} differs only in case from ${v2.symbol.javaClassName}. " + "Such classes will overwrite one another on case-insensitive filesystems.") } @@ -141,7 +141,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { try emitFor(c) catch { case e: FileConflictException => - c.cunit.error(c.symbol.pos, s"error writing ${c.symbol}: ${e.getMessage}") + reporter.error(c.symbol.pos, s"error writing ${c.symbol}: ${e.getMessage}") } sortedClasses = sortedClasses.tail classes -= c.symbol // GC opportunity @@ -1363,7 +1363,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { if (m.symbol.isStaticConstructor || definitions.isGetClass(m.symbol)) return if (m.params.size > MaximumJvmParameters) { - getCurrentCUnit().error(m.symbol.pos, s"Platform restriction: a parameter list's length cannot exceed $MaximumJvmParameters.") + reporter.error(m.symbol.pos, s"Platform restriction: a parameter list's length cannot exceed $MaximumJvmParameters.") return } @@ -3245,7 +3245,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { } if(!isValidSignature) { - unit.warning(sym.pos, + reporter.warning(sym.pos, """|compiler bug: created invalid generic signature for %s in %s |signature: %s |if this is reproducible, please report bug at https://issues.scala-lang.org/ @@ -3258,7 +3258,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { val normalizedTpe = enteringErasure(erasure.prepareSigMap(memberTpe)) val bytecodeTpe = owner.thisType.memberInfo(sym) if (!sym.isType && !sym.isConstructor && !(erasure.erasure(sym)(normalizedTpe) =:= bytecodeTpe)) { - unit.warning(sym.pos, + reporter.warning(sym.pos, """|compiler bug: created generic signature for %s in %s that does not conform to its erasure |signature: %s |original type: %s diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala index 9b292fee7fb0..a401de05e5bf 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala @@ -156,7 +156,7 @@ abstract class GenBCode extends BCodeSyncAndTry { case None => caseInsensitively.put(lowercaseJavaClassName, claszSymbol) case Some(dupClassSym) => - item.cunit.warning( + reporter.warning( claszSymbol.pos, s"Class ${claszSymbol.javaClassName} differs only in case from ${dupClassSym.javaClassName}. " + "Such classes will overwrite one another on case-insensitive filesystems." diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVMASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVMASM.scala index 01c4ff5a52b7..2bcde7f7b9aa 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVMASM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVMASM.scala @@ -27,7 +27,7 @@ trait GenJVMASM { protected def isJavaEntryPoint(icls: IClass) = { val sym = icls.symbol def fail(msg: String, pos: Position = sym.pos) = { - icls.cunit.warning(sym.pos, + reporter.warning(sym.pos, sym.name + " has a main method with parameter type Array[String], but " + sym.fullName('.') + " will not be a runnable program.\n" + " Reason: " + msg // TODO: make this next claim true, if possible diff --git a/src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala b/src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala index 235e954f8842..425c10d1536f 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/InlineExceptionHandlers.scala @@ -182,7 +182,7 @@ abstract class InlineExceptionHandlers extends SubComponent { // in other words: what's on the stack MUST conform to what's in the THROW(..)! if (!canReplaceHandler) { - currentClass.cunit.warning(NoPosition, "Unable to inline the exception handler inside incorrect" + + reporter.warning(NoPosition, "Unable to inline the exception handler inside incorrect" + " block:\n" + bblock.iterator.mkString("\n") + "\nwith stack: " + typeInfo + " just " + "before instruction index " + index) } @@ -383,7 +383,7 @@ abstract class InlineExceptionHandlers extends SubComponent { Some((exceptionLocal, copy)) case _ => - currentClass.cunit.warning(NoPosition, "Unable to inline the exception handler due to incorrect format:\n" + + reporter.warning(NoPosition, "Unable to inline the exception handler due to incorrect format:\n" + handler.iterator.mkString("\n")) None } diff --git a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala index f6de522d09bd..8df3969c49e7 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala @@ -195,7 +195,7 @@ abstract class Inliners extends SubComponent { /** The current iclass */ private var currentIClazz: IClass = _ - private def warn(pos: Position, msg: String) = currentIClazz.cunit.inlinerWarning(pos, msg) + private def warn(pos: Position, msg: String) = currentRun.reporting.inlinerWarning(pos, msg) private def ownedName(sym: Symbol): String = exitingUncurry { val count = ( diff --git a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala index a61ad392ee71..37b00aa9a3ed 100644 --- a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala +++ b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala @@ -26,10 +26,10 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners { def freshName(prefix: String): Name = freshTermName(prefix) def freshTermName(prefix: String): TermName = unit.freshTermName(prefix) def freshTypeName(prefix: String): TypeName = unit.freshTypeName(prefix) - def deprecationWarning(off: Int, msg: String) = unit.deprecationWarning(off, msg) + def deprecationWarning(off: Int, msg: String) = currentRun.reporting.deprecationWarning(off, msg) implicit def i2p(offset : Int) : Position = Position.offset(unit.source, offset) - def warning(pos : Int, msg : String) : Unit = unit.warning(pos, msg) - def syntaxError(pos: Int, msg: String) : Unit = unit.error(pos, msg) + def warning(pos : Int, msg : String) : Unit = reporter.warning(pos, msg) + def syntaxError(pos: Int, msg: String) : Unit = reporter.error(pos, msg) } abstract class JavaParser extends ParserCommon { diff --git a/src/compiler/scala/tools/nsc/javac/JavaScanners.scala b/src/compiler/scala/tools/nsc/javac/JavaScanners.scala index c5401219dd9c..bddcf6567cb1 100644 --- a/src/compiler/scala/tools/nsc/javac/JavaScanners.scala +++ b/src/compiler/scala/tools/nsc/javac/JavaScanners.scala @@ -860,9 +860,9 @@ trait JavaScanners extends ast.parser.ScannersCommon { class JavaUnitScanner(unit: CompilationUnit) extends JavaScanner { in = new JavaCharArrayReader(unit.source.content, !settings.nouescape.value, syntaxError) init() - def error (pos: Int, msg: String) = unit. error(pos, msg) - def incompleteInputError(pos: Int, msg: String) = unit.incompleteInputError(pos, msg) - def deprecationWarning(pos: Int, msg: String) = unit.deprecationWarning(pos, msg) + def error (pos: Int, msg: String) = reporter.error(pos, msg) + def incompleteInputError(pos: Int, msg: String) = currentRun.reporting.incompleteInputError(pos, msg) + def deprecationWarning(pos: Int, msg: String) = currentRun.reporting.deprecationWarning(pos, msg) implicit def g2p(pos: Int): Position = Position.offset(unit.source, pos) } } diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala index 592c5497b552..2fc00fe068c5 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala @@ -69,7 +69,7 @@ abstract class Pickler extends SubComponent { // OPT: do this only as a recovery after fatal error. Checking in advance was expensive. if (t.isErroneous) { if (settings.debug) e.printStackTrace() - unit.error(t.pos, "erroneous or inaccessible type") + reporter.error(t.pos, "erroneous or inaccessible type") return } } diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala index f14fce5de972..1664fe0e0d0e 100644 --- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala +++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala @@ -76,7 +76,7 @@ abstract class CleanUp extends Statics with Transform with ast.TreeDSL { val qual0 = ad.qual val params = ad.args if (settings.logReflectiveCalls) - unit.echo(ad.pos, "method invocation uses reflection") + reporter.echo(ad.pos, "method invocation uses reflection") val typedPos = typedWithPos(ad.pos) _ @@ -360,13 +360,13 @@ abstract class CleanUp extends Statics with Transform with ast.TreeDSL { assert(params.length == mparams.length, ((params, mparams))) (mparams, resType) case tpe @ OverloadedType(pre, alts) => - unit.warning(ad.pos, s"Overloaded type reached the backend! This is a bug in scalac.\n Symbol: ${ad.symbol}\n Overloads: $tpe\n Arguments: " + ad.args.map(_.tpe)) + reporter.warning(ad.pos, s"Overloaded type reached the backend! This is a bug in scalac.\n Symbol: ${ad.symbol}\n Overloads: $tpe\n Arguments: " + ad.args.map(_.tpe)) alts filter (_.paramss.flatten.size == params.length) map (_.tpe) match { case mt @ MethodType(mparams, resType) :: Nil => - unit.warning(NoPosition, "Only one overload has the right arity, proceeding with overload " + mt) + reporter.warning(NoPosition, "Only one overload has the right arity, proceeding with overload " + mt) (mparams, resType) case _ => - unit.error(ad.pos, "Cannot resolve overload.") + reporter.error(ad.pos, "Cannot resolve overload.") (Nil, NoType) } } diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala index 391bce5abbf6..f471440293a6 100644 --- a/src/compiler/scala/tools/nsc/transform/Constructors.scala +++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala @@ -54,7 +54,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL { def check(tree: Tree) = { for (t <- tree) t match { case t: RefTree if uninitializedVals(t.symbol.accessedOrSelf) && t.qualifier.symbol == clazz => - unit.warning(t.pos, s"Reference to uninitialized ${t.symbol.accessedOrSelf}") + reporter.warning(t.pos, s"Reference to uninitialized ${t.symbol.accessedOrSelf}") case _ => } } @@ -685,7 +685,7 @@ abstract class Constructors extends Statics with Transform with ast.TreeDSL { // mangling before we introduce more of it. val conflict = clazz.info.nonPrivateMember(acc.name) filter (s => s.isGetter && !s.isOuterField && s.enclClass.isTrait) if (conflict ne NoSymbol) - unit.error(acc.pos, "parameter '%s' requires field but conflicts with %s".format(acc.name, conflict.fullLocationString)) + reporter.error(acc.pos, "parameter '%s' requires field but conflicts with %s".format(acc.name, conflict.fullLocationString)) copyParam(acc, parameter(acc)) } diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala index 2f2142027fe2..ec4deb6be03e 100644 --- a/src/compiler/scala/tools/nsc/transform/Erasure.scala +++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala @@ -488,7 +488,7 @@ abstract class Erasure extends AddInterfaces || (checkBridgeOverrides(member, other, bridge) match { case Nil => true case es if member.owner.isAnonymousClass => resolveAnonymousBridgeClash(member, bridge); true - case es => for ((pos, msg) <- es) unit.error(pos, msg); false + case es => for ((pos, msg) <- es) reporter.error(pos, msg); false }) ) @@ -724,7 +724,7 @@ abstract class Erasure extends AddInterfaces ) val when = if (exitingRefchecks(lowType matches highType)) "" else " after erasure: " + exitingPostErasure(highType) - unit.error(pos, + reporter.error(pos, s"""|$what: |${exitingRefchecks(highString)} and |${exitingRefchecks(lowString)} @@ -865,7 +865,7 @@ abstract class Erasure extends AddInterfaces fn match { case TypeApply(sel @ Select(qual, name), List(targ)) => if (qual.tpe != null && isPrimitiveValueClass(qual.tpe.typeSymbol) && targ.tpe != null && targ.tpe <:< AnyRefTpe) - unit.error(sel.pos, "isInstanceOf cannot test if value types are references.") + reporter.error(sel.pos, "isInstanceOf cannot test if value types are references.") def mkIsInstanceOf(q: () => Tree)(tp: Type): Tree = Apply( @@ -952,7 +952,7 @@ abstract class Erasure extends AddInterfaces case nme.length => nme.array_length case nme.update => nme.array_update case nme.clone_ => nme.array_clone - case _ => unit.error(tree.pos, "Unexpected array member, no translation exists.") ; nme.NO_NAME + case _ => reporter.error(tree.pos, "Unexpected array member, no translation exists.") ; nme.NO_NAME } gen.mkRuntimeCall(arrayMethodName, qual :: args) } @@ -1055,7 +1055,7 @@ abstract class Erasure extends AddInterfaces qual match { case Super(_, _) => // Insert a cast here at your peril -- see SI-5162. - unit.error(tree.pos, s"Unable to access ${tree.symbol.fullLocationString} with a super reference.") + reporter.error(tree.pos, s"Unable to access ${tree.symbol.fullLocationString} with a super reference.") tree case _ => // Todo: Figure out how qual.tpe could be null in the check above (it does appear in build where SwingWorker.this diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala index 0447e23e9eed..c2919614472a 100644 --- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala +++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala @@ -481,7 +481,7 @@ abstract class ExplicitOuter extends InfoTransform // since we can't fix SI-4440 properly (we must drop the outer accessors of final classes when there's no immediate reference to them in sight) // at least don't crash... this duplicates maybeOmittable from constructors (acc.owner.isEffectivelyFinal && !acc.isOverridingSymbol)) { - unit.uncheckedWarning(tree.pos, "The outer reference in this type test cannot be checked at run time.") + currentRun.reporting.uncheckedWarning(tree.pos, "The outer reference in this type test cannot be checked at run time.") transform(TRUE) // urgh... drop condition if there's no accessor (or if it may disappear after constructors) } else { // println("(base, acc)= "+(base, acc)) diff --git a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala index 2235a93ca442..228c9da624f0 100644 --- a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala +++ b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala @@ -127,7 +127,7 @@ abstract class ExtensionMethods extends Transform with TypingTransformers { def checkNonCyclic(pos: Position, seen: Set[Symbol], clazz: Symbol): Unit = if (seen contains clazz) - unit.error(pos, "value class may not unbox to itself") + reporter.error(pos, "value class may not unbox to itself") else { val unboxed = definitions.underlyingOfValueClass(clazz).typeSymbol if (unboxed.isDerivedValueClass) checkNonCyclic(pos, seen + clazz, unboxed) diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala index e38c034f4dc2..f85d8222f06f 100644 --- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala +++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala @@ -339,7 +339,7 @@ abstract class LambdaLift extends InfoTransform { if (clazz.isStaticOwner) clazz.fullLocationString else s"the unconstructed `this` of ${clazz.fullLocationString}" val msg = s"Implementation restriction: access of ${sym.fullLocationString} from ${currentClass.fullLocationString}, would require illegal premature access to $what" - currentUnit.error(curTree.pos, msg) + reporter.error(curTree.pos, msg) } val qual = if (clazz == currentClass) gen.mkAttributedThis(clazz) diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala index 313d0a6e617d..792787558378 100644 --- a/src/compiler/scala/tools/nsc/transform/Mixin.scala +++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala @@ -336,7 +336,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL { rebindSuper(clazz, mixinMember.alias, mixinClass) match { case NoSymbol => - unit.error(clazz.pos, "Member %s of mixin %s is missing a concrete super implementation.".format( + reporter.error(clazz.pos, "Member %s of mixin %s is missing a concrete super implementation.".format( mixinMember.alias, mixinClass)) case alias1 => superAccessor.asInstanceOf[TermSymbol] setAlias alias1 diff --git a/src/compiler/scala/tools/nsc/transform/TailCalls.scala b/src/compiler/scala/tools/nsc/transform/TailCalls.scala index d9d1192772fa..ef534f70fd94 100644 --- a/src/compiler/scala/tools/nsc/transform/TailCalls.scala +++ b/src/compiler/scala/tools/nsc/transform/TailCalls.scala @@ -96,7 +96,7 @@ abstract class TailCalls extends Transform { val failReason = failReasons(ctx) val failPos = failPositions(ctx) - unit.error(failPos, s"could not optimize @tailrec annotated $method: $failReason") + reporter.error(failPos, s"could not optimize @tailrec annotated $method: $failReason") } /** Has the label been accessed? Then its symbol is in this set. */ @@ -268,14 +268,14 @@ abstract class TailCalls extends Transform { tree match { case ValDef(_, _, _, _) => if (tree.symbol.isLazy && tree.symbol.hasAnnotation(TailrecClass)) - unit.error(tree.pos, "lazy vals are not tailcall transformed") + reporter.error(tree.pos, "lazy vals are not tailcall transformed") super.transform(tree) case dd @ DefDef(_, name, _, vparamss0, _, rhs0) if isEligible(dd) => val newCtx = new DefDefTailContext(dd) if (newCtx.isMandatory && !(newCtx containsRecursiveCall rhs0)) - unit.error(tree.pos, "@tailrec annotated method contains no recursive calls") + reporter.error(tree.pos, "@tailrec annotated method contains no recursive calls") debuglog(s"Considering $name for tailcalls, with labels in tailpos: ${newCtx.tailLabels}") val newRHS = transform(rhs0, newCtx) diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala index d77c6b54a97a..2209aac00f87 100644 --- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala +++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala @@ -93,7 +93,7 @@ abstract class UnCurry extends InfoTransform override def transform(tree: Tree): Tree = ( try postTransform(mainTransform(tree)) catch { case ex: TypeError => - unit.error(ex.pos, ex.msg) + reporter.error(ex.pos, ex.msg) debugStack(ex) EmptyTree } @@ -174,7 +174,7 @@ abstract class UnCurry extends InfoTransform cdef <- catches if catchesThrowable(cdef) && !isSyntheticCase(cdef) } { - unit.warning(body.pos, "catch block may intercept non-local return from " + meth) + reporter.warning(body.pos, "catch block may intercept non-local return from " + meth) } Block(List(keyDef), tryCatch) @@ -706,10 +706,10 @@ abstract class UnCurry extends InfoTransform */ private def saveRepeatedParams(dd: DefDef): Unit = if (dd.symbol.isConstructor) - unit.error(dd.symbol.pos, "A constructor cannot be annotated with a `varargs` annotation.") + reporter.error(dd.symbol.pos, "A constructor cannot be annotated with a `varargs` annotation.") else treeInfo.repeatedParams(dd) match { case Nil => - unit.error(dd.symbol.pos, "A method without repeated parameters cannot be annotated with the `varargs` annotation.") + reporter.error(dd.symbol.pos, "A method without repeated parameters cannot be annotated with the `varargs` annotation.") case reps => repeatedParams(dd.symbol) = reps } @@ -782,7 +782,7 @@ abstract class UnCurry extends InfoTransform // check if the method with that name and those arguments already exists in the template currentClass.info.member(forwsym.name).alternatives.find(s => s != forwsym && s.tpe.matches(forwsym.tpe)) match { - case Some(s) => unit.error(dd.symbol.pos, + case Some(s) => reporter.error(dd.symbol.pos, "A method with a varargs annotation produces a forwarder method with the same signature " + s.tpe + " as an existing method.") case None => diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala index e1a663ea416a..6f81cbe15230 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala @@ -51,7 +51,7 @@ trait TreeAndTypeAnalysis extends Debugging { // This is a pretty poor approximation. def unsoundAssumptionUsed = binder.name != nme.WILDCARD && !(pt <:< pat.tpe) if (settings.lint && unsoundAssumptionUsed) - global.currentUnit.warning(pat.pos, + reporter.warning(pat.pos, sm"""The value matched by $pat is bound to ${binder.name}, which may be used under the |unsound assumption that it has type ${pat.tpe}, whereas we can only safely |count on it having type $pt, as the pattern is matched using `==` (see SI-1503).""") @@ -398,7 +398,7 @@ trait MatchAnalysis extends MatchApproximation { import global.definitions._ trait MatchAnalyzer extends MatchApproximator { - def uncheckedWarning(pos: Position, msg: String) = global.currentUnit.uncheckedWarning(pos, msg) + def uncheckedWarning(pos: Position, msg: String) = currentRun.reporting.uncheckedWarning(pos, msg) def warn(pos: Position, ex: AnalysisBudget.Exception, kind: String) = uncheckedWarning(pos, s"Cannot check match for $kind.\n${ex.advice}") // TODO: model dependencies between variables: if V1 corresponds to (x: List[_]) and V2 is (x.hd), V2 cannot be assigned when V1 = null or V1 = Nil diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala index 8ff782415931..e9c81f47289d 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala @@ -442,7 +442,7 @@ trait MatchOptimization extends MatchTreeMaking with MatchAnalysis { val distinctAlts = distinctBy(switchableAlts)(extractConst) if (distinctAlts.size < switchableAlts.size) { val duplicated = switchableAlts.groupBy(extractConst).flatMap(_._2.drop(1).take(1)) // report the first duplicated - global.currentUnit.warning(pos, s"Pattern contains duplicate alternatives: ${duplicated.mkString(", ")}") + reporter.warning(pos, s"Pattern contains duplicate alternatives: ${duplicated.mkString(", ")}") } CaseDef(Alternative(distinctAlts), guard, body) } diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala index 4cf898068931..0eaffe7ceeee 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala @@ -154,7 +154,7 @@ trait MatchTranslation { case SymbolBound(sym, expr) => bindingStep(sym, expr) case Literal(Constant(_)) | Ident(_) | Select(_, _) | This(_) => equalityTestStep() case Alternative(alts) => alternativesStep(alts) - case _ => context.unit.error(pos, unsupportedPatternMsg) ; noStep() + case _ => reporter.error(pos, unsupportedPatternMsg) ; noStep() } def translate(): List[TreeMaker] = nextStep() merge (_.translate()) diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala index 5d8a9fecefef..1974befb4530 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala @@ -558,7 +558,7 @@ trait MatchTreeMaking extends MatchCodeGen with Debugging { } emitSwitch(scrut, scrutSym, casesNoSubstOnly, pt, matchFailGenOverride, suppression.exhaustive).getOrElse{ - if (requireSwitch) typer.context.unit.warning(scrut.pos, "could not emit switch for @switch annotated match") + if (requireSwitch) reporter.warning(scrut.pos, "could not emit switch for @switch annotated match") if (casesNoSubstOnly nonEmpty) { // before optimizing, check casesNoSubstOnly for presence of a default case, diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala index a7d7680db1c3..9e9372f7096e 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchWarnings.scala @@ -67,7 +67,7 @@ trait MatchWarnings { val cdef = it.next() // If a default case has been seen, then every succeeding case is unreachable. if (vpat != null) - context.unit./*error*/warning(cdef.body.pos, "unreachable code due to " + vpat + addendum(cdef.pat)) + reporter.warning(cdef.body.pos, "unreachable code due to " + vpat + addendum(cdef.pat)) // TODO: make configurable whether this is an error // If this is a default case and more cases follow, warn about this one so // we have a reason to mention its pattern variable name and any corresponding // symbol in scope. Errors will follow from the remaining cases, at least @@ -78,7 +78,7 @@ trait MatchWarnings { case _ => "" } vpat = s"variable pattern$vpatName on line ${cdef.pat.pos.line}" - context.unit.warning(cdef.pos, s"patterns after a variable pattern cannot match (SLS 8.1.1)" + addendum(cdef.pat)) + reporter.warning(cdef.pos, s"patterns after a variable pattern cannot match (SLS 8.1.1)" + addendum(cdef.pat)) } } } diff --git a/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala b/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala index f6c960d089ee..ef50e083a1b4 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala @@ -65,7 +65,7 @@ trait PatternMatching extends Transform } catch { case x: (Types#TypeError) => // TODO: this should never happen; error should've been reported during type checking - unit.error(tree.pos, "error during expansion of this match (this is a scalac bug).\nThe underlying error was: "+ x.msg) + reporter.error(tree.pos, "error during expansion of this match (this is a scalac bug).\nThe underlying error was: "+ x.msg) translated } case Try(block, catches, finalizer) => @@ -175,13 +175,13 @@ trait Interface extends ast.TreeDSL { val matchOwner = typer.context.owner def pureType(tp: Type): Type = tp - def reportUnreachable(pos: Position) = typer.context.unit.warning(pos, "unreachable code") + def reportUnreachable(pos: Position) = reporter.warning(pos, "unreachable code") def reportMissingCases(pos: Position, counterExamples: List[String]) = { val ceString = if (counterExamples.tail.isEmpty) "input: " + counterExamples.head else "inputs: " + counterExamples.mkString(", ") - typer.context.unit.warning(pos, "match may not be exhaustive.\nIt would fail on the following "+ ceString) + reporter.warning(pos, "match may not be exhaustive.\nIt would fail on the following "+ ceString) } } diff --git a/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala b/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala index c19786d5e7e4..8f21f4ecfcba 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala @@ -103,8 +103,8 @@ trait ScalacPatternExpanders { def offerString = if (extractor.isErroneous) "" else s" offering $offering" def arityExpected = ( if (extractor.hasSeq) "at least " else "" ) + productArity - def err(msg: String) = currentUnit.error(tree.pos, msg) - def warn(msg: String) = currentUnit.warning(tree.pos, msg) + def err(msg: String) = reporter.error(tree.pos, msg) + def warn(msg: String) = reporter.warning(tree.pos, msg) def arityError(what: String) = err(s"$what patterns for $owner$offerString: expected $arityExpected, found $totalArity") if (isStar && !isSeq) @@ -141,7 +141,7 @@ trait ScalacPatternExpanders { if (requiresTupling && effectivePatternArity(args) == 1) { val sym = sel.symbol.owner - currentUnit.deprecationWarning(sel.pos, sym, s"${sym} expects $productArity patterns$acceptMessage but crushing into $productArity-tuple to fit single pattern (SI-6675)") + currentRun.reporting.deprecationWarning(sel.pos, sym, s"${sym} expects $productArity patterns$acceptMessage but crushing into $productArity-tuple to fit single pattern (SI-6675)") } val normalizedExtractor = if (requiresTupling) tupleExtractor(extractor) else extractor diff --git a/src/compiler/scala/tools/nsc/typechecker/Checkable.scala b/src/compiler/scala/tools/nsc/typechecker/Checkable.scala index 13884404b3be..3a77cab919d0 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Checkable.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Checkable.scala @@ -275,7 +275,7 @@ trait Checkable { ; // Matching on types like case _: AnyRef { def bippy: Int } => doesn't work -- yet. case RefinedType(_, decls) if !decls.isEmpty => - getContext.unit.warning(tree.pos, s"a pattern match on a refinement type is unchecked") + reporter.warning(tree.pos, s"a pattern match on a refinement type is unchecked") case RefinedType(parents, _) => parents foreach (p => checkCheckable(tree, p, X, inPattern, canRemedy)) case _ => @@ -285,14 +285,14 @@ trait Checkable { if (checker.neverMatches) { val addendum = if (checker.neverSubClass) "" else " (but still might match its erasure)" - getContext.unit.warning(tree.pos, s"fruitless type test: a value of type $X cannot also be a $PString$addendum") + reporter.warning(tree.pos, s"fruitless type test: a value of type $X cannot also be a $PString$addendum") } else if (checker.isUncheckable) { val msg = ( if (checker.uncheckableType =:= P) s"abstract type $where$PString" else s"${checker.uncheckableMessage} in type $where$PString" ) - getContext.unit.warning(tree.pos, s"$msg is unchecked since it is eliminated by erasure") + reporter.warning(tree.pos, s"$msg is unchecked since it is eliminated by erasure") } } } diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 03890f30f645..20f0405d1bfd 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -66,7 +66,7 @@ trait Contexts { self: Analyzer => def isMask(s: ImportSelector) = s.name != nme.WILDCARD && s.rename == nme.WILDCARD imp.tree.selectors filterNot (s => isMask(s) || used(s)) foreach { sel => - unit.warning(imp posOf sel, "Unused import") + reporter.warning(imp posOf sel, "Unused import") } } allUsedSelectors --= imps @@ -103,7 +103,7 @@ trait Contexts { self: Analyzer => // there must be a scala.xml package when xml literals were parsed in this unit if (unit.hasXml && ScalaXmlPackage == NoSymbol) - unit.error(unit.firstXmlPos, "To compile XML syntax, the scala.xml package must be on the classpath.\nPlease see http://docs.scala-lang.org/overviews/core/scala-2.11.html#scala-xml.") + reporter.error(unit.firstXmlPos, "To compile XML syntax, the scala.xml package must be on the classpath.\nPlease see http://docs.scala-lang.org/overviews/core/scala-2.11.html#scala-xml.") // scala-xml needs `scala.xml.TopScope` to be in scope globally as `$scope` // We detect `scala-xml` by looking for `scala.xml.TopScope` and @@ -359,7 +359,7 @@ trait Contexts { self: Analyzer => /** Issue and clear all warnings from the report buffer */ def flushAndIssueWarnings() { reportBuffer.warnings foreach { - case (pos, msg) => unit.warning(pos, msg) + case (pos, msg) => reporter.warning(pos, msg) } reportBuffer.clearAllWarnings() } @@ -541,7 +541,7 @@ trait Contexts { self: Analyzer => } private def unitError(pos: Position, msg: String): Unit = - if (checking) onTreeCheckerError(pos, msg) else unit.error(pos, msg) + if (checking) onTreeCheckerError(pos, msg) else reporter.error(pos, msg) @inline private def issueCommon(err: AbsTypeError)(pf: PartialFunction[AbsTypeError, Unit]) { // TODO: are errors allowed to have pos == NoPosition?? @@ -589,7 +589,7 @@ trait Contexts { self: Analyzer => /** Issue/throw the given error message according to the current mode for error reporting. */ def warning(pos: Position, msg: String, force: Boolean = false) { - if (reportErrors || force) unit.warning(pos, msg) + if (reportErrors || force) reporter.warning(pos, msg) else if (bufferErrors) reportBuffer += (pos -> msg) } diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index fc0e2c7c803f..a3f1da60ce94 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -558,7 +558,7 @@ trait Infer extends Checkable { foreachWithIndex(targs) ((targ, idx) => targ.typeSymbol match { case sym @ (AnyClass | AnyValClass) => - context.unit.warning(argumentPosition(idx), s"a type was inferred to be `${sym.name}`; this may indicate a programming error.") + reporter.warning(argumentPosition(idx), s"a type was inferred to be `${sym.name}`; this may indicate a programming error.") case _ => } ) diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index 099031d536fa..1328119aacf7 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -443,7 +443,7 @@ trait Namers extends MethodSynthesis { && clazz.exists ) if (fails) { - context.unit.error(tree.pos, ( + reporter.error(tree.pos, ( s"Companions '$clazz' and '$module' must be defined in same file:\n" + s" Found in ${clazz.sourceFile.canonicalPath} and ${module.sourceFile.canonicalPath}") ) @@ -718,7 +718,7 @@ trait Namers extends MethodSynthesis { } val owner = tree.symbol.owner if (settings.lint && owner.isPackageObjectClass && !mods.isImplicit) { - context.unit.warning(tree.pos, + reporter.warning(tree.pos, "it is not recommended to define classes/objects inside of package objects.\n" + "If possible, define " + tree.symbol + " in " + owner.skipPackageObject + " instead." ) @@ -730,7 +730,7 @@ trait Namers extends MethodSynthesis { log("enter implicit wrapper "+tree+", owner = "+owner) enterImplicitWrapper(tree) } - else context.unit.error(tree.pos, "implicit classes must accept exactly one primary constructor parameter") + else reporter.error(tree.pos, "implicit classes must accept exactly one primary constructor parameter") } validateCompanionDefs(tree) } diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index 0d79637c88ff..1c84f8d759ea 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -147,7 +147,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans val owners = haveDefaults map (_.owner) // constructors of different classes are allowed to have defaults if (haveDefaults.exists(x => !x.isConstructor) || owners.distinct.size < haveDefaults.size) { - unit.error(clazz.pos, + reporter.error(clazz.pos, "in "+ clazz + ", multiple overloaded alternatives of "+ haveDefaults.head + " define default arguments" + ( @@ -162,7 +162,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans // Check for doomed attempt to overload applyDynamic if (clazz isSubClass DynamicClass) { for ((_, m1 :: m2 :: _) <- (clazz.info member nme.applyDynamic).alternatives groupBy (_.typeParams.length)) { - unit.error(m1.pos, "implementation restriction: applyDynamic cannot be overloaded except by methods with different numbers of type parameters, e.g. applyDynamic[T1](method: String)(arg: T1) and applyDynamic[T1, T2](method: String)(arg1: T1, arg2: T2)") + reporter.error(m1.pos, "implementation restriction: applyDynamic cannot be overloaded except by methods with different numbers of type parameters, e.g. applyDynamic[T1](method: String)(arg: T1) and applyDynamic[T1, T2](method: String)(arg1: T1, arg2: T2)") } } @@ -172,7 +172,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans // implicit classes leave both a module symbol and a method symbol as residue val alts = clazz.info.decl(sym.name).alternatives filterNot (_.isModule) if (alts.size > 1) - alts foreach (x => unit.warning(x.pos, "parameterized overloaded implicit methods are not visible as view bounds")) + alts foreach (x => reporter.warning(x.pos, "parameterized overloaded implicit methods are not visible as view bounds")) } } } @@ -281,10 +281,10 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans mixinOverrideErrors.toList match { case List() => case List(MixinOverrideError(_, msg)) => - unit.error(clazz.pos, msg) + reporter.error(clazz.pos, msg) case MixinOverrideError(member, msg) :: others => val others1 = others.map(_.member.name.decode).filter(member.name.decode != _).distinct - unit.error( + reporter.error( clazz.pos, msg+(if (others1.isEmpty) "" else ";\n other members with override errors are: "+(others1 mkString ", "))) @@ -347,7 +347,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans ) } def emitOverrideError(fullmsg: String) { - if (member.owner == clazz) unit.error(member.pos, fullmsg) + if (member.owner == clazz) reporter.error(member.pos, fullmsg) else mixinOverrideErrors += new MixinOverrideError(member, fullmsg) } @@ -464,7 +464,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans checkOverrideDeprecated() if (settings.warnNullaryOverride) { if (other.paramss.isEmpty && !member.paramss.isEmpty) { - unit.warning(member.pos, "non-nullary method overrides nullary method") + reporter.warning(member.pos, "non-nullary method overrides nullary method") } } } @@ -496,7 +496,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans typer.infer.checkKindBounds(high :: Nil, lowType :: Nil, rootType, low.owner) match { // (1.7.2) case Nil => case kindErrors => - unit.error(member.pos, + reporter.error(member.pos, "The kind of "+member.keyString+" "+member.varianceString + member.nameString+ " does not conform to the expected kind of " + other.defString + other.locationString + "." + kindErrors.toList.mkString("\n", ", ", "")) @@ -507,7 +507,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans typer.infer.checkKindBounds(low :: Nil, lowType.normalize :: Nil, rootType, low.owner) match { case Nil => case kindErrors => - unit.error(member.pos, + reporter.error(member.pos, "The kind of the right-hand side "+lowType.normalize+" of "+low.keyString+" "+ low.varianceString + low.nameString+ " does not conform to its expected kind."+ kindErrors.toList.mkString("\n", ", ", "")) @@ -546,7 +546,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans if (other.hasDeprecatedOverridingAnnotation) { val suffix = other.deprecatedOverridingMessage map (": " + _) getOrElse "" val msg = s"overriding ${other.fullLocationString} is deprecated$suffix" - unit.deprecationWarning(member.pos, other, msg) + currentRun.reporting.deprecationWarning(member.pos, other, msg) } } } @@ -754,7 +754,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans checkNoAbstractDecls(clazz) if (abstractErrors.nonEmpty) - unit.error(clazz.pos, abstractErrorMessage) + reporter.error(clazz.pos, abstractErrorMessage) } else if (clazz.isTrait && !(clazz isSubClass AnyValClass)) { // For non-AnyVal classes, prevent abstract methods in interfaces that override @@ -765,7 +765,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans // override a concrete method in Object. The jvm, however, does not. val overridden = decl.matchingSymbol(ObjectClass, ObjectTpe) if (overridden.isFinal) - unit.error(decl.pos, "trait cannot redefine final method from class AnyRef") + reporter.error(decl.pos, "trait cannot redefine final method from class AnyRef") } } @@ -818,7 +818,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans // for (bc <- clazz.info.baseClasses.tail) Console.println("" + bc + " has " + bc.info.decl(member.name) + ":" + bc.info.decl(member.name).tpe);//DEBUG val nonMatching: List[Symbol] = clazz.info.member(member.name).alternatives.filterNot(_.owner == clazz).filterNot(_.isFinal) - def issueError(suffix: String) = unit.error(member.pos, member.toString() + " overrides nothing" + suffix) + def issueError(suffix: String) = reporter.error(member.pos, member.toString() + " overrides nothing" + suffix) nonMatching match { case Nil => issueError("") @@ -871,7 +871,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans case _ :: Nil => ;// OK case tp1 :: tp2 :: _ => - unit.error(clazz.pos, "illegal inheritance;\n " + clazz + + reporter.error(clazz.pos, "illegal inheritance;\n " + clazz + " inherits different type instances of " + baseClass + ":\n" + tp1 + " and " + tp2) explainTypes(tp1, tp2) @@ -888,7 +888,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans case _ => "type "+tp } override def issueVarianceError(base: Symbol, sym: Symbol, required: Variance) { - currentRun.currentUnit.error(base.pos, + reporter.error(base.pos, s"${sym.variance} $sym occurs in $required position in ${tpString(base.info)} of $base") } } @@ -956,7 +956,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans def checkImplicitViewOptionApply(pos: Position, fn: Tree, args: List[Tree]): Unit = if (settings.lint) (fn, args) match { case (tap@TypeApply(fun, targs), List(view: ApplyImplicitView)) if fun.symbol == currentRun.runDefinitions.Option_apply => - unit.warning(pos, s"Suspicious application of an implicit view (${view.fun}) in the argument to Option.apply.") // SI-6567 + reporter.warning(pos, s"Suspicious application of an implicit view (${view.fun}) in the argument to Option.apply.") // SI-6567 case _ => } @@ -1031,7 +1031,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans def nonSensibleWarning(what: String, alwaysEqual: Boolean) = { val msg = alwaysEqual == (name == nme.EQ || name == nme.eq) - unit.warning(pos, s"comparing $what using `${name.decode}' will always yield $msg") + reporter.warning(pos, s"comparing $what using `${name.decode}' will always yield $msg") isNonSensible = true } def nonSensible(pre: String, alwaysEqual: Boolean) = @@ -1046,7 +1046,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans } def unrelatedTypes() = if (!isNonSensible) { val weaselWord = if (isEitherValueClass) "" else " most likely" - unit.warning(pos, s"$typesString are unrelated: they will$weaselWord $unrelatedMsg") + reporter.warning(pos, s"$typesString are unrelated: they will$weaselWord $unrelatedMsg") } if (nullCount == 2) // null == null @@ -1141,7 +1141,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans && callsSelf ) if (trivialInifiniteLoop) - unit.warning(valOrDef.rhs.pos, s"${valOrDef.symbol.fullLocationString} does nothing other than call itself recursively") + reporter.warning(valOrDef.rhs.pos, s"${valOrDef.symbol.fullLocationString} does nothing other than call itself recursively") } // Transformation ------------------------------------------------------------ @@ -1231,7 +1231,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans finally if (currentLevel.maxindex > 0) { // An implementation restriction to avoid VerifyErrors and lazyvals mishaps; see SI-4717 debuglog("refsym = " + currentLevel.refsym) - unit.error(currentLevel.refpos, "forward reference not allowed from self constructor invocation") + reporter.error(currentLevel.refpos, "forward reference not allowed from self constructor invocation") } case ModuleDef(_, _, _) => eliminateModuleDefs(tree) case ValDef(_, _, _, _) => @@ -1241,7 +1241,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans val lazySym = tree.symbol.lazyAccessorOrSelf if (lazySym.isLocalToBlock && index <= currentLevel.maxindex) { debuglog("refsym = " + currentLevel.refsym) - unit.error(currentLevel.refpos, "forward reference extends over definition of " + lazySym) + reporter.error(currentLevel.refpos, "forward reference extends over definition of " + lazySym) } tree1 :: Nil } @@ -1255,7 +1255,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans try typer.infer.checkBounds(tree0, pre, owner, tparams, argtps, "") catch { case ex: TypeError => - unit.error(tree0.pos, ex.getMessage()) + reporter.error(tree0.pos, ex.getMessage()) if (settings.explaintypes) { val bounds = tparams map (tp => tp.info.instantiateTypeParams(tparams, argtps).bounds) (argtps, bounds).zipped map ((targ, bound) => explainTypes(bound.lo, targ)) @@ -1288,7 +1288,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans // If symbol is deprecated, and the point of reference is not enclosed // in either a deprecated member or a scala bridge method, issue a warning. if (sym.isDeprecated && !currentOwner.ownerChain.exists(x => x.isDeprecated || x.hasBridgeAnnotation)) - unit.deprecationWarning(pos, sym, s"${sym}${sym.locationString} is deprecated${sym.deprecationMessage map (": " + _) getOrElse ""}") + currentRun.reporting.deprecationWarning(pos, sym, s"${sym}${sym.locationString} is deprecated${sym.deprecationMessage map (": " + _) getOrElse ""}") // Similar to deprecation: check if the symbol is marked with @migration // indicating it has changed semantics between versions. @@ -1297,12 +1297,12 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans settings.Xmigration.value < ScalaVersion(sym.migrationVersion.get) catch { case e : NumberFormatException => - unit.warning(pos, s"${sym.fullLocationString} has an unparsable version number: ${e.getMessage()}") + reporter.warning(pos, s"${sym.fullLocationString} has an unparsable version number: ${e.getMessage()}") // if we can't parse the format on the migration annotation just conservatively assume it changed true } if (changed) - unit.warning(pos, s"${sym.fullLocationString} has changed semantics in version ${sym.migrationVersion.get}:\n${sym.migrationMessage.get}") + reporter.warning(pos, s"${sym.fullLocationString} has changed semantics in version ${sym.migrationVersion.get}:\n${sym.migrationMessage.get}") } // See an explanation of compileTimeOnly in its scaladoc at scala.annotation.compileTimeOnly. if (sym.isCompileTimeOnly) { @@ -1310,7 +1310,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans sm"""Reference to ${sym.fullLocationString} should not have survived past type checking, |it should have been processed and eliminated during expansion of an enclosing macro.""" // The getOrElse part should never happen, it's just here as a backstop. - unit.error(pos, sym.compileTimeOnlyMessage getOrElse defaultMsg) + reporter.error(pos, sym.compileTimeOnlyMessage getOrElse defaultMsg) } } @@ -1321,7 +1321,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans && sym.accessedOrSelf.isVal ) if (settings.lint.value && isLikelyUninitialized) - unit.warning(pos, s"Selecting ${sym} from ${sym.owner}, which extends scala.DelayedInit, is likely to yield an uninitialized value") + reporter.warning(pos, s"Selecting ${sym} from ${sym.owner}, which extends scala.DelayedInit, is likely to yield an uninitialized value") } private def lessAccessible(otherSym: Symbol, memberSym: Symbol): Boolean = ( @@ -1353,7 +1353,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans if (memberSym.isDeferred) "may be unable to provide a concrete implementation of" else "may be unable to override" - unit.warning(memberSym.pos, + reporter.warning(memberSym.pos, "%s%s references %s %s.".format( memberSym.fullLocationString, comparison, accessFlagsToString(otherSym), otherSym @@ -1388,7 +1388,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans tree match { case DefDef(_, name, _, params :: _, _, _) => if (settings.lint && !treeInfo.isLeftAssoc(name.decodedName) && params.exists(p => isByName(p.symbol))) - unit.warning(tree.pos, + reporter.warning(tree.pos, "by-name parameters will be evaluated eagerly when called as a right-associative infix operator. For more details, see SI-1980.") case _ => } @@ -1405,7 +1405,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans symbol.allOverriddenSymbols.filter(sym => !sym.isDeprecated && !sym.isDeferred) if(!concrOvers.isEmpty) - unit.deprecationWarning( + currentRun.reporting.deprecationWarning( tree.pos, symbol, s"${symbol.toString} overrides concrete, non-deprecated symbol(s): ${concrOvers.map(_.name.decode).mkString(", ")}") @@ -1469,7 +1469,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans applyChecks(sym.annotations) // validate implicitNotFoundMessage analyzer.ImplicitNotFoundMsg.check(sym) foreach { warn => - unit.warning(tree.pos, f"Invalid implicitNotFound message for ${sym}%s${sym.locationString}%s:%n$warn") + reporter.warning(tree.pos, f"Invalid implicitNotFound message for ${sym}%s${sym.locationString}%s:%n$warn") } case tpt@TypeTree() => @@ -1594,7 +1594,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans || sym.allOverriddenSymbols.exists(over => !(over.tpe.resultType =:= sym.tpe.resultType)) ) if (!isOk) - unit.warning(sym.pos, s"side-effecting nullary methods are discouraged: suggest defining as `def ${sym.name.decode}()` instead") + reporter.warning(sym.pos, s"side-effecting nullary methods are discouraged: suggest defining as `def ${sym.name.decode}()` instead") case _ => () } @@ -1602,15 +1602,15 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans private def checkAnyValSubclass(clazz: Symbol) = { if (clazz.isDerivedValueClass) { if (clazz.isTrait) - unit.error(clazz.pos, "Only classes (not traits) are allowed to extend AnyVal") + reporter.error(clazz.pos, "Only classes (not traits) are allowed to extend AnyVal") else if (clazz.hasAbstractFlag) - unit.error(clazz.pos, "`abstract' modifier cannot be used with value classes") + reporter.error(clazz.pos, "`abstract' modifier cannot be used with value classes") } } private def checkUnexpandedMacro(t: Tree) = if (!t.isDef && t.hasSymbolField && t.symbol.isTermMacro) - unit.error(t.pos, "macro has not been expanded") + reporter.error(t.pos, "macro has not been expanded") override def transform(tree: Tree): Tree = { val savedLocalTyper = localTyper @@ -1705,7 +1705,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans tree case treeInfo.WildcardStarArg(_) if !isRepeatedParamArg(tree) => - unit.error(tree.pos, "no `: _*' annotation allowed here\n"+ + reporter.error(tree.pos, "no `: _*' annotation allowed here\n"+ "(such annotations are only allowed in arguments to *-parameters)") tree @@ -1778,7 +1778,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans } catch { case ex: TypeError => if (settings.debug) ex.printStackTrace() - unit.error(tree.pos, ex.getMessage()) + reporter.error(tree.pos, ex.getMessage()) tree } finally { localTyper = savedLocalTyper diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala index b6d37ab9a77a..d3a41b9570ca 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala @@ -124,7 +124,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT if (other == NoSymbol) other = linked.info.decl(sym.name.toTermName).filter(_.isModule) if (other != NoSymbol) - unit.error(sym.pos, "name clash: "+sym.owner+" defines "+sym+ + reporter.error(sym.pos, "name clash: "+sym.owner+" defines "+sym+ "\nand its companion "+sym.owner.companionModule+" also defines "+ other) } @@ -139,14 +139,14 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT val member = sym.overridingSymbol(clazz) if (mix != tpnme.EMPTY || member == NoSymbol || !(member.isAbstractOverride && member.isIncompleteIn(clazz))) - unit.error(sel.pos, ""+sym.fullLocationString+" is accessed from super. It may not be abstract "+ + reporter.error(sel.pos, ""+sym.fullLocationString+" is accessed from super. It may not be abstract "+ "unless it is overridden by a member declared `abstract' and `override'") } else if (mix == tpnme.EMPTY && !sym.owner.isTrait){ // SI-4989 Check if an intermediate class between `clazz` and `sym.owner` redeclares the method as abstract. val intermediateClasses = clazz.info.baseClasses.tail.takeWhile(_ != sym.owner) intermediateClasses.map(sym.overridingSymbol).find(s => s.isDeferred && !s.isAbstractOverride && !s.owner.isTrait).foreach { absSym => - unit.error(sel.pos, s"${sym.fullLocationString} cannot be directly accessed from ${clazz} because ${absSym.owner} redeclares it as abstract") + reporter.error(sel.pos, s"${sym.fullLocationString} cannot be directly accessed from ${clazz} because ${absSym.owner} redeclares it as abstract") } } @@ -252,7 +252,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT qual.symbol.ancestors foreach { parent => parent.info.decls filterNot (x => x.isPrivate || x.isLocalToThis) foreach { m2 => if (sym.name == m2.name && m2.isGetter && m2.accessed.isMutable) { - unit.warning(sel.pos, + reporter.warning(sel.pos, sym.accessString + " " + sym.fullLocationString + " shadows mutable " + m2.name + " inherited from " + m2.owner + ". Changes to " + m2.name + " will not be visible within " + sym.owner + " - you may want to give them distinct names.") @@ -310,9 +310,9 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT case Super(_, mix) => if (sym.isValue && !sym.isMethod || sym.hasAccessorFlag) { if (!settings.overrideVars) - unit.error(tree.pos, "super may be not be used on " + sym.accessedOrSelf) + reporter.error(tree.pos, "super may be not be used on " + sym.accessedOrSelf) } else if (isDisallowed(sym)) { - unit.error(tree.pos, "super not allowed here: use this." + name.decode + " instead") + reporter.error(tree.pos, "super not allowed here: use this." + name.decode + " instead") } transformSuperSelect(sel) diff --git a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala index a2f52e190546..399a4ca8d50c 100644 --- a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala @@ -17,7 +17,7 @@ abstract class TreeCheckers extends Analyzer { override protected def onTreeCheckerError(pos: Position, msg: String) { if (settings.fatalWarnings) - currentUnit.warning(pos, "\n** Error during internal checking:\n" + msg) + reporter.warning(pos, "\n** Error during internal checking:\n" + msg) } case class DiffResult[T](lost: List[T], gained: List[T]) { @@ -170,7 +170,7 @@ abstract class TreeCheckers extends Analyzer { ) - def errorFn(pos: Position, msg: Any): Unit = currentUnit.warning(pos, "[check: %s] %s".format(phase.prev, msg)) + def errorFn(pos: Position, msg: Any): Unit = reporter.warning(pos, "[check: %s] %s".format(phase.prev, msg)) def errorFn(msg: Any): Unit = errorFn(NoPosition, msg) def informFn(msg: Any) { diff --git a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala index 60346e7be17d..7440f69e9383 100644 --- a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala +++ b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala @@ -41,9 +41,9 @@ trait TypeDiagnostics { * indicate that the restriction may be lifted in the future. */ def restrictionWarning(pos: Position, unit: CompilationUnit, msg: String): Unit = - unit.warning(pos, "Implementation restriction: " + msg) + reporter.warning(pos, "Implementation restriction: " + msg) def restrictionError(pos: Position, unit: CompilationUnit, msg: String): Unit = - unit.error(pos, "Implementation restriction: " + msg) + reporter.error(pos, "Implementation restriction: " + msg) /** A map of Positions to addendums - if an error involves a position in * the map, the addendum should also be printed. @@ -435,12 +435,8 @@ trait TypeDiagnostics { trait TyperDiagnostics { self: Typer => - private def contextError(context0: Analyzer#Context, pos: Position, msg: String) = context0.error(pos, msg) - private def contextError(context0: Analyzer#Context, pos: Position, err: Throwable) = context0.error(pos, err) - private def contextWarning(pos: Position, msg: String) = context.unit.warning(pos, msg) - def permanentlyHiddenWarning(pos: Position, hidden: Name, defn: Symbol) = - contextWarning(pos, "imported `%s' is permanently hidden by definition of %s".format(hidden, defn.fullLocationString)) + context.warning(pos, "imported `%s' is permanently hidden by definition of %s".format(hidden, defn.fullLocationString)) object checkUnused { val ignoreNames = Set[TermName]("readResolve", "readObject", "writeObject", "writeReplace") @@ -542,15 +538,15 @@ trait TypeDiagnostics { else if (sym.isModule) "object" else "term" ) - unit.warning(pos, s"$why $what in ${sym.owner} is never used") + reporter.warning(pos, s"$why $what in ${sym.owner} is never used") } p.unsetVars foreach { v => - unit.warning(v.pos, s"local var ${v.name} in ${v.owner} is never set - it could be a val") + reporter.warning(v.pos, s"local var ${v.name} in ${v.owner} is never set - it could be a val") } p.unusedTypes foreach { t => val sym = t.symbol val why = if (sym.isPrivate) "private" else "local" - unit.warning(t.pos, s"$why ${sym.fullLocationString} is never used") + reporter.warning(t.pos, s"$why ${sym.fullLocationString} is never used") } } } @@ -627,13 +623,13 @@ trait TypeDiagnostics { case Import(expr, _) => expr.pos case _ => ex.pos } - contextError(context0, pos, cyclicReferenceMessage(sym, info.tree) getOrElse ex.getMessage()) + context0.error(pos, cyclicReferenceMessage(sym, info.tree) getOrElse ex.getMessage()) if (sym == ObjectClass) throw new FatalError("cannot redefine root "+sym) } case _ => - contextError(context0, ex.pos, ex) + context0.error(ex.pos, ex) } } } diff --git a/src/compiler/scala/tools/reflect/FormatInterpolator.scala b/src/compiler/scala/tools/reflect/FormatInterpolator.scala index e0f9bb604489..57be1afdfee1 100644 --- a/src/compiler/scala/tools/reflect/FormatInterpolator.scala +++ b/src/compiler/scala/tools/reflect/FormatInterpolator.scala @@ -117,7 +117,7 @@ abstract class FormatInterpolator { c.error(errPoint, msg("unsupported")) s0 } else { - c.enclosingUnit.deprecationWarning(errPoint, msg("deprecated")) + currentRun.reporting.deprecationWarning(errPoint, msg("deprecated")) try StringContext.treatEscapes(s0) catch escapeHatch } } diff --git a/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala b/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala index e5c64c6f45e0..10c382e16987 100644 --- a/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala +++ b/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala @@ -39,12 +39,12 @@ trait ScaladocAnalyzer extends Analyzer { for (useCase <- comment.useCases) { typer1.silent(_.asInstanceOf[ScaladocTyper].defineUseCases(useCase)) match { case SilentTypeError(err) => - unit.warning(useCase.pos, err.errMsg) + reporter.warning(useCase.pos, err.errMsg) case _ => } for (useCaseSym <- useCase.defined) { if (sym.name != useCaseSym.name) - unit.warning(useCase.pos, "@usecase " + useCaseSym.name.decode + " does not match commented symbol: " + sym.name.decode) + reporter.warning(useCase.pos, "@usecase " + useCaseSym.name.decode + " does not match commented symbol: " + sym.name.decode) } } } @@ -191,7 +191,7 @@ abstract class ScaladocSyntaxAnalyzer[G <: Global](val global: G) extends Syntax } def isDirty = unclean(unmooredParser parseComment doc) if ((doc ne null) && (settings.lint || isDirty)) - unit.warning(doc.pos, "discarding unmoored doc comment") + reporter.warning(doc.pos, "discarding unmoored doc comment") } override def flushDoc(): DocComment = (try lastDoc finally lastDoc = null) From 9fc68e19309cef139c4827fbed76952011995e10 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 24 Jun 2014 15:54:10 +0200 Subject: [PATCH 363/826] Remove deprecationWarning, currentReporting from Reporting This moves us a bit closer to the goal of having a single entry point to reporting. Must modularize Reporting a bit so it can be used in Variances (need a reference to `currentRun` in `reflect.internal.Reporting`). --- bincompat-forward.whitelist.conf | 12 +++++++ src/compiler/scala/tools/nsc/Global.scala | 7 ++--- src/compiler/scala/tools/nsc/Reporting.scala | 25 ++------------- .../scala/reflect/internal/Reporting.scala | 31 ++++++++++++++++--- .../scala/reflect/internal/Variances.scala | 2 +- .../scala/reflect/runtime/JavaUniverse.scala | 8 +++++ .../symtab/SymbolTableForUnitTesting.scala | 7 +++++ 7 files changed, 59 insertions(+), 33 deletions(-) diff --git a/bincompat-forward.whitelist.conf b/bincompat-forward.whitelist.conf index dbf0807999a1..30dac79974fd 100644 --- a/bincompat-forward.whitelist.conf +++ b/bincompat-forward.whitelist.conf @@ -242,6 +242,18 @@ filter { { matchName="scala.reflect.runtime.JavaUniverse.reporter" problemName=MissingMethodProblem + }, + { + matchName="scala.reflect.runtime.JavaUniverse$PerRunReporting" + problemName=MissingClassProblem + }, + { + matchName="scala.reflect.runtime.JavaUniverse.currentRun" + problemName=MissingMethodProblem + }, + { + matchName="scala.reflect.runtime.JavaUniverse.PerRunReporting" + problemName=MissingMethodProblem } ] } diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index a6fa3bf1dccd..572e579aca2e 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -1045,7 +1045,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter) def currentUnit: CompilationUnit = if (currentRun eq null) NoCompilationUnit else currentRun.currentUnit def currentSource: SourceFile = if (currentUnit.exists) currentUnit.source else lastSeenSourceFile def currentFreshNameCreator = currentUnit.fresh - def currentReporting = currentRun.reporting def isGlobalInitialized = ( definitions.isDefinitionsInitialized @@ -1093,7 +1092,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) /** Don't want to introduce new errors trying to report errors, * so swallow exceptions. */ - def supplementTyperState(errorMessage: String): String = try { + override def supplementTyperState(errorMessage: String): String = try { val tree = analyzer.lastTreeToTyper val sym = tree.symbol val tpe = tree.tpe @@ -1156,7 +1155,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) /** A Run is a single execution of the compiler on a set of units. */ - class Run extends RunContextApi { + class Run extends RunContextApi with RunReporting { /** Have been running into too many init order issues with Run * during erroneous conditions. Moved all these vals up to the * top of the file so at least they're not trivially null. @@ -1165,8 +1164,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter) /** The currently compiled unit; set from GlobalPhase */ var currentUnit: CompilationUnit = NoCompilationUnit - val reporting = new PerRunReporting - // used in sbt def uncheckedWarnings: List[(Position, String)] = reporting.uncheckedWarnings // used in sbt diff --git a/src/compiler/scala/tools/nsc/Reporting.scala b/src/compiler/scala/tools/nsc/Reporting.scala index 1b5a77823530..9a2080714505 100644 --- a/src/compiler/scala/tools/nsc/Reporting.scala +++ b/src/compiler/scala/tools/nsc/Reporting.scala @@ -18,24 +18,13 @@ import scala.collection.{ mutable, immutable } trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions with CompilationUnits with scala.reflect.api.Symbols => def settings: Settings - // == currentRun.reporting - def currentReporting: PerRunReporting - - def supplementTyperState(errorMessage: String): String - // not deprecated yet, but a method called "error" imported into // nearly every trait really must go. For now using globalError. def error(msg: String) = globalError(msg) - override def deprecationWarning(pos: Position, msg: String) = currentReporting.deprecationWarning(pos, msg) - override def supplementErrorMessage(errorMessage: String) = currentReporting.supplementErrorMessage(errorMessage) - - // a new instance of this class is created for every Run (access the current instance via `currentReporting`) - class PerRunReporting { - // NOTE: scala.reflect.macros.Parsers#parse relies on everything related to reporting going through this def... - // TODO: can we rework this to avoid the indirection/fragility? - def reporter = Reporting.this.reporter - + // a new instance of this class is created for every Run (access the current instance via `currentRun.reporting`) + protected def PerRunReporting = new PerRunReporting + class PerRunReporting extends PerRunReportingBase { /** Collects for certain classes of warnings during this run. */ private class ConditionalWarning(what: String, option: Settings#BooleanSetting) { val warnings = mutable.LinkedHashMap[Position, String]() @@ -126,13 +115,5 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w if (incompleteHandled) incompleteHandler(pos, msg) else reporter.error(pos, msg) - /** Have we already supplemented the error message of a compiler crash? */ - private[this] var supplementedError = false - def supplementErrorMessage(errorMessage: String): String = - if (supplementedError) errorMessage - else { - supplementedError = true - supplementTyperState(errorMessage) - } } } \ No newline at end of file diff --git a/src/reflect/scala/reflect/internal/Reporting.scala b/src/reflect/scala/reflect/internal/Reporting.scala index 0670e9bd8e50..423127803eb5 100644 --- a/src/reflect/scala/reflect/internal/Reporting.scala +++ b/src/reflect/scala/reflect/internal/Reporting.scala @@ -16,6 +16,32 @@ package internal */ trait Reporting { self : Positions => def reporter: Reporter + def currentRun: RunReporting + + trait RunReporting { + val reporting: PerRunReporting = PerRunReporting + } + + type PerRunReporting <: PerRunReportingBase + protected def PerRunReporting: PerRunReporting + abstract class PerRunReportingBase { + def deprecationWarning(pos: Position, msg: String): Unit + + /** Have we already supplemented the error message of a compiler crash? */ + private[this] var supplementedError = false + def supplementErrorMessage(errorMessage: String): String = + if (supplementedError) errorMessage + else { + supplementedError = true + supplementTyperState(errorMessage) + } + + } + + // overridden in Global + def supplementTyperState(errorMessage: String): String = errorMessage + + def supplementErrorMessage(errorMessage: String) = currentRun.reporting.supplementErrorMessage(errorMessage) @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2") def inform(msg: String): Unit = inform(NoPosition, msg) @@ -39,11 +65,6 @@ trait Reporting { self : Positions => def warning(pos: Position, msg: String) = reporter.warning(pos, msg) @deprecatedOverriding("This forwards to the corresponding method in reporter -- override reporter instead", "2.11.2") def globalError(pos: Position, msg: String) = reporter.error(pos, msg) - - def deprecationWarning(pos: Position, msg: String): Unit = warning(msg) - - /** Overridden when we know more about what was happening during a failure. */ - def supplementErrorMessage(msg: String): String = msg } import util.Position diff --git a/src/reflect/scala/reflect/internal/Variances.scala b/src/reflect/scala/reflect/internal/Variances.scala index cfe2ad8b87da..12b765b7a60b 100644 --- a/src/reflect/scala/reflect/internal/Variances.scala +++ b/src/reflect/scala/reflect/internal/Variances.scala @@ -79,7 +79,7 @@ trait Variances { // Unsound pre-2.11 behavior preserved under -Xsource:2.10 if (settings.isScala211 || sym.isOverridingSymbol) Invariant else { - deprecationWarning(sym.pos, s"Construct depends on unsound variance analysis and will not compile in scala 2.11 and beyond") + currentRun.reporting.deprecationWarning(sym.pos, s"Construct depends on unsound variance analysis and will not compile in scala 2.11 and beyond") Bivariant } ) diff --git a/src/reflect/scala/reflect/runtime/JavaUniverse.scala b/src/reflect/scala/reflect/runtime/JavaUniverse.scala index d846ef2cdd75..fe39e1f245ff 100644 --- a/src/reflect/scala/reflect/runtime/JavaUniverse.scala +++ b/src/reflect/scala/reflect/runtime/JavaUniverse.scala @@ -27,6 +27,14 @@ class JavaUniverse extends InternalSymbolTable with JavaUniverseForce with Refle protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit = log(msg) } + // minimal Run to get Reporting wired + def currentRun = new RunReporting {} + class PerRunReporting extends PerRunReportingBase { + def deprecationWarning(pos: Position, msg: String): Unit = reporter.warning(pos, msg) + } + protected def PerRunReporting = new PerRunReporting + + type TreeCopier = InternalTreeCopierOps implicit val TreeCopierTag: ClassTag[TreeCopier] = ClassTag[TreeCopier](classOf[TreeCopier]) def newStrictTreeCopier: TreeCopier = new StrictTreeCopier diff --git a/test/junit/scala/tools/nsc/symtab/SymbolTableForUnitTesting.scala b/test/junit/scala/tools/nsc/symtab/SymbolTableForUnitTesting.scala index 6b87a99e6fbb..91868a568377 100644 --- a/test/junit/scala/tools/nsc/symtab/SymbolTableForUnitTesting.scala +++ b/test/junit/scala/tools/nsc/symtab/SymbolTableForUnitTesting.scala @@ -77,6 +77,13 @@ class SymbolTableForUnitTesting extends SymbolTable { protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit = println(msg) } + // minimal Run to get Reporting wired + def currentRun = new RunReporting {} + class PerRunReporting extends PerRunReportingBase { + def deprecationWarning(pos: Position, msg: String): Unit = reporter.warning(pos, msg) + } + protected def PerRunReporting = new PerRunReporting + // Members declared in scala.reflect.internal.SymbolTable def currentRunId: Int = 1 def log(msg: => AnyRef): Unit = println(msg) From 3066bd4c7b2f574748208b7399c68c6c6493206b Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 24 Jun 2014 14:34:05 +0200 Subject: [PATCH 364/826] Encapsulate deprecation warning message synthesis. Both refchecks and typer constructed the same message. But different. Now with more DRYness. Note that no check files had to be updated (disconcerting)... --- src/compiler/scala/tools/nsc/Reporting.scala | 6 +++++- src/compiler/scala/tools/nsc/typechecker/Contexts.scala | 2 ++ src/compiler/scala/tools/nsc/typechecker/RefChecks.scala | 2 +- src/compiler/scala/tools/nsc/typechecker/Typers.scala | 2 +- 4 files changed, 9 insertions(+), 3 deletions(-) diff --git a/src/compiler/scala/tools/nsc/Reporting.scala b/src/compiler/scala/tools/nsc/Reporting.scala index 9a2080714505..bc27afb0c567 100644 --- a/src/compiler/scala/tools/nsc/Reporting.scala +++ b/src/compiler/scala/tools/nsc/Reporting.scala @@ -15,7 +15,7 @@ import scala.collection.{ mutable, immutable } * * TODO: make reporting configurable */ -trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions with CompilationUnits with scala.reflect.api.Symbols => +trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions with CompilationUnits with scala.reflect.internal.Symbols => def settings: Settings // not deprecated yet, but a method called "error" imported into @@ -65,6 +65,10 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w // behold! the symbol that caused the deprecation warning (may not be deprecated itself) def deprecationWarning(pos: Position, sym: Symbol, msg: String): Unit = _deprecationWarnings.warn(pos, msg) + def deprecationWarning(pos: Position, sym: Symbol): Unit = { + val suffix = sym.deprecationMessage match { case Some(msg) => ": "+ msg case _ => "" } + deprecationWarning(pos, sym, s"$sym${sym.locationString} is deprecated$suffix") + } private[this] var reportedFeature = Set[Symbol]() def featureWarning(pos: Position, featureName: String, featureDesc: String, featureTrait: Symbol, construct: => String = "", required: Boolean): Unit = { diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 20f0405d1bfd..72ca9b879aa8 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -595,6 +595,8 @@ trait Contexts { self: Analyzer => def deprecationWarning(pos: Position, sym: Symbol, msg: String): Unit = currentRun.reporting.deprecationWarning(pos, sym, msg) + def deprecationWarning(pos: Position, sym: Symbol): Unit = + currentRun.reporting.deprecationWarning(pos, sym) // TODO: allow this to escalate to an error, and implicit search will ignore deprecated implicits def featureWarning(pos: Position, featureName: String, featureDesc: String, featureTrait: Symbol, construct: => String = "", required: Boolean): Unit = currentRun.reporting.featureWarning(pos, featureName, featureDesc, featureTrait, construct, required) diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index 1c84f8d759ea..1b3da26bf293 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -1288,7 +1288,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans // If symbol is deprecated, and the point of reference is not enclosed // in either a deprecated member or a scala bridge method, issue a warning. if (sym.isDeprecated && !currentOwner.ownerChain.exists(x => x.isDeprecated || x.hasBridgeAnnotation)) - currentRun.reporting.deprecationWarning(pos, sym, s"${sym}${sym.locationString} is deprecated${sym.deprecationMessage map (": " + _) getOrElse ""}") + currentRun.reporting.deprecationWarning(pos, sym) // Similar to deprecation: check if the symbol is marked with @migration // indicating it has changed semantics between versions. diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 349bad555a11..2c31ef2e8eab 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -942,7 +942,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper def adaptConstant(value: Constant): Tree = { val sym = tree.symbol if (sym != null && sym.isDeprecated) - context.deprecationWarning(tree.pos, sym, s"${sym.toString}${sym.locationString} is deprecated: ${sym.deprecationMessage.getOrElse("")}") + context.deprecationWarning(tree.pos, sym) treeCopy.Literal(tree, value) } From b384d5070f86e9003e8f1b57cc818520033242ab Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 3 Jul 2014 13:40:55 +0200 Subject: [PATCH 365/826] Use countElementsAsString for summarized warnings. --- src/compiler/scala/tools/nsc/Reporting.scala | 8 ++++---- test/files/jvm/deprecation.check | 2 +- test/files/jvm/serialization-new.check | 2 +- test/files/jvm/serialization.check | 2 +- test/files/neg/checksensible.check | 2 +- test/files/neg/overloaded-implicit.check | 2 +- test/files/run/colltest.check | 2 +- test/files/run/inferred-type-constructors.check | 2 +- test/files/run/names-defaults.check | 2 +- test/files/run/richs.check | 2 +- test/files/run/t2212.check | 2 +- test/files/run/t3996.check | 2 +- test/files/run/t4080.check | 2 +- test/files/run/t4461.check | 2 +- test/files/run/t4813.check | 2 +- test/files/run/t6111.check | 2 +- test/files/run/t6690.check | 2 +- test/files/run/t6863.check | 2 +- test/files/run/t8196.check | 2 +- test/files/run/t8549.check | 2 +- 20 files changed, 23 insertions(+), 23 deletions(-) diff --git a/src/compiler/scala/tools/nsc/Reporting.scala b/src/compiler/scala/tools/nsc/Reporting.scala index bc27afb0c567..0263586418a0 100644 --- a/src/compiler/scala/tools/nsc/Reporting.scala +++ b/src/compiler/scala/tools/nsc/Reporting.scala @@ -9,6 +9,7 @@ package nsc import reporters.{ Reporter, ConsoleReporter } import scala.collection.{ mutable, immutable } +import scala.reflect.internal.util.StringOps.countElementsAsString /** Provides delegates to the reporter doing the actual work. * PerRunReporting implements per-Run stateful info tracking and reporting @@ -34,11 +35,10 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w def summarize() = if (warnings.nonEmpty && (option.isDefault || settings.fatalWarnings)) { val numWarnings = warnings.size - val warningEvent = // TODO use scala.reflect.internal.util.StringOps.countElementsAsString(numWarnings, s"$what warning") - if (numWarnings > 1) s"were $numWarnings $what warnings" - else s"was one $what warning" + val warningVerb = if (numWarnings == 1) "was" else "were" + val warningCount = countElementsAsString(numWarnings, s"$what warning") - reporter.warning(NoPosition, s"there $warningEvent; re-run with ${option.name} for details") + reporter.warning(NoPosition, s"there $warningVerb $warningCount; re-run with ${option.name} for details") } } diff --git a/test/files/jvm/deprecation.check b/test/files/jvm/deprecation.check index 3c27d4d08201..d57b6b55a592 100644 --- a/test/files/jvm/deprecation.check +++ b/test/files/jvm/deprecation.check @@ -1,3 +1,3 @@ -warning: there were 4 deprecation warnings; re-run with -deprecation for details +warning: there were four deprecation warnings; re-run with -deprecation for details Note: deprecation/Use_2.java uses or overrides a deprecated API. Note: Recompile with -Xlint:deprecation for details. diff --git a/test/files/jvm/serialization-new.check b/test/files/jvm/serialization-new.check index 8ec5754ea2fc..155513592681 100644 --- a/test/files/jvm/serialization-new.check +++ b/test/files/jvm/serialization-new.check @@ -1,4 +1,4 @@ -warning: there were 2 deprecation warnings; re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details a1 = Array[1,2,3] _a1 = Array[1,2,3] arrayEquals(a1, _a1): true diff --git a/test/files/jvm/serialization.check b/test/files/jvm/serialization.check index 8ec5754ea2fc..155513592681 100644 --- a/test/files/jvm/serialization.check +++ b/test/files/jvm/serialization.check @@ -1,4 +1,4 @@ -warning: there were 2 deprecation warnings; re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details a1 = Array[1,2,3] _a1 = Array[1,2,3] arrayEquals(a1, _a1): true diff --git a/test/files/neg/checksensible.check b/test/files/neg/checksensible.check index 1b53fa5fb9d0..7de22fef5475 100644 --- a/test/files/neg/checksensible.check +++ b/test/files/neg/checksensible.check @@ -97,7 +97,7 @@ checksensible.scala:84: warning: comparing values of types EqEqRefTest.this.C3 a checksensible.scala:95: warning: comparing values of types Unit and Int using `!=' will always yield true while ((c = in.read) != -1) ^ -warning: there were 3 deprecation warnings; re-run with -deprecation for details +warning: there were three deprecation warnings; re-run with -deprecation for details error: No warnings can be incurred under -Xfatal-warnings. 34 warnings found one error found diff --git a/test/files/neg/overloaded-implicit.check b/test/files/neg/overloaded-implicit.check index 5cf6ac528b5a..0e6617d90433 100644 --- a/test/files/neg/overloaded-implicit.check +++ b/test/files/neg/overloaded-implicit.check @@ -4,7 +4,7 @@ overloaded-implicit.scala:2: warning: parameterized overloaded implicit methods overloaded-implicit.scala:3: warning: parameterized overloaded implicit methods are not visible as view bounds implicit def imp1[T](x: Set[T]): Map[T, T] = Map() ^ -warning: there were 4 feature warnings; re-run with -feature for details +warning: there were four feature warnings; re-run with -feature for details error: No warnings can be incurred under -Xfatal-warnings. three warnings found one error found diff --git a/test/files/run/colltest.check b/test/files/run/colltest.check index 46e4017eb6df..9579d781aac6 100644 --- a/test/files/run/colltest.check +++ b/test/files/run/colltest.check @@ -1,4 +1,4 @@ -warning: there were 2 deprecation warnings; re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details true false true diff --git a/test/files/run/inferred-type-constructors.check b/test/files/run/inferred-type-constructors.check index 67075a59a9e6..4a63853bd985 100644 --- a/test/files/run/inferred-type-constructors.check +++ b/test/files/run/inferred-type-constructors.check @@ -1,4 +1,4 @@ -warning: there were 2 feature warnings; re-run with -feature for details +warning: there were two feature warnings; re-run with -feature for details p.Iterable[Int] p.Set[Int] p.Seq[Int] diff --git a/test/files/run/names-defaults.check b/test/files/run/names-defaults.check index 97cfa4e52030..25999c488aff 100644 --- a/test/files/run/names-defaults.check +++ b/test/files/run/names-defaults.check @@ -1,7 +1,7 @@ names-defaults.scala:269: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses spawn(b = { val ttt = 1; ttt }, a = 0) ^ -warning: there were 4 deprecation warnings; re-run with -deprecation for details +warning: there were four deprecation warnings; re-run with -deprecation for details 1: @ get: $ get: 2 diff --git a/test/files/run/richs.check b/test/files/run/richs.check index bcaf8bdb8d03..cf265ae00738 100644 --- a/test/files/run/richs.check +++ b/test/files/run/richs.check @@ -1,4 +1,4 @@ -warning: there were 2 deprecation warnings; re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details RichCharTest1: true diff --git a/test/files/run/t2212.check b/test/files/run/t2212.check index f7e80439c7bf..1465f1341aa2 100644 --- a/test/files/run/t2212.check +++ b/test/files/run/t2212.check @@ -1,4 +1,4 @@ -warning: there were 2 deprecation warnings; re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details LinkedList(1) LinkedList(1) true diff --git a/test/files/run/t3996.check b/test/files/run/t3996.check index 2e8e558f8896..a9ecc29fea08 100644 --- a/test/files/run/t3996.check +++ b/test/files/run/t3996.check @@ -1 +1 @@ -warning: there were 2 deprecation warnings; re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t4080.check b/test/files/run/t4080.check index c642cc67daf5..462e925b7694 100644 --- a/test/files/run/t4080.check +++ b/test/files/run/t4080.check @@ -1,2 +1,2 @@ -warning: there were 3 deprecation warnings; re-run with -deprecation for details +warning: there were three deprecation warnings; re-run with -deprecation for details LinkedList(1, 0, 2, 3) diff --git a/test/files/run/t4461.check b/test/files/run/t4461.check index c44b0fc07746..346993af6f48 100644 --- a/test/files/run/t4461.check +++ b/test/files/run/t4461.check @@ -1,4 +1,4 @@ -warning: there were 4 deprecation warnings; re-run with -deprecation for details +warning: there were four deprecation warnings; re-run with -deprecation for details Include(End,1) Include(End,2) Include(End,3) diff --git a/test/files/run/t4813.check b/test/files/run/t4813.check index 2e8e558f8896..a9ecc29fea08 100644 --- a/test/files/run/t4813.check +++ b/test/files/run/t4813.check @@ -1 +1 @@ -warning: there were 2 deprecation warnings; re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t6111.check b/test/files/run/t6111.check index 21a5b19ea09a..588065800198 100644 --- a/test/files/run/t6111.check +++ b/test/files/run/t6111.check @@ -1,3 +1,3 @@ -warning: there were 2 deprecation warnings; re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details (8,8) (x,x) diff --git a/test/files/run/t6690.check b/test/files/run/t6690.check index 2e8e558f8896..a9ecc29fea08 100644 --- a/test/files/run/t6690.check +++ b/test/files/run/t6690.check @@ -1 +1 @@ -warning: there were 2 deprecation warnings; re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t6863.check b/test/files/run/t6863.check index 37de2e6e51a0..d4df5f7a74bc 100644 --- a/test/files/run/t6863.check +++ b/test/files/run/t6863.check @@ -10,4 +10,4 @@ t6863.scala:46: warning: comparing values of types Unit and Unit using `==' will t6863.scala:59: warning: comparing values of types Unit and Unit using `==' will always yield true assert({ () => x }.apply == ()) ^ -warning: there were 4 deprecation warnings; re-run with -deprecation for details +warning: there were four deprecation warnings; re-run with -deprecation for details diff --git a/test/files/run/t8196.check b/test/files/run/t8196.check index f021a3619fd6..d11dc27e68d9 100644 --- a/test/files/run/t8196.check +++ b/test/files/run/t8196.check @@ -1,7 +1,7 @@ t8196.scala:26: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses form2.g1 // comment this line in order to make the test pass ^ -warning: there were 2 feature warnings; re-run with -feature for details +warning: there were two feature warnings; re-run with -feature for details Scope{ final private val f1: Int } diff --git a/test/files/run/t8549.check b/test/files/run/t8549.check index 2e8e558f8896..a9ecc29fea08 100644 --- a/test/files/run/t8549.check +++ b/test/files/run/t8549.check @@ -1 +1 @@ -warning: there were 2 deprecation warnings; re-run with -deprecation for details +warning: there were two deprecation warnings; re-run with -deprecation for details From e3311073bbad6f6f0dfdd3ea09628d324b4b3614 Mon Sep 17 00:00:00 2001 From: Maks Atygaev Date: Sat, 5 Jul 2014 10:23:23 +0700 Subject: [PATCH 366/826] [scaladoc] Changed align of example code to Option.contains and Option.collect methods. --- src/library/scala/Option.scala | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/src/library/scala/Option.scala b/src/library/scala/Option.scala index 9371775d6728..d263f89bb8d3 100644 --- a/src/library/scala/Option.scala +++ b/src/library/scala/Option.scala @@ -211,16 +211,16 @@ sealed abstract class Option[+A] extends Product with Serializable { /** Tests whether the option contains a given value as an element. * - * @example {{{ - * // Returns true because Some instance contains string "something" which equals "something". - * Some("something") contains "something" + * @example {{{ + * // Returns true because Some instance contains string "something" which equals "something". + * Some("something") contains "something" * - * // Returns false because "something" != "anything". - * Some("something") contains "anything" + * // Returns false because "something" != "anything". + * Some("something") contains "anything" * - * // Returns false when method called on None. - * None contains "anything" - * }}} + * // Returns false when method called on None. + * None contains "anything" + * }}} * * @param elem the element to test. * @return `true` if the option has an element that is equal (as @@ -262,16 +262,16 @@ sealed abstract class Option[+A] extends Product with Serializable { * nonempty '''and''' `pf` is defined for that value. * Returns $none otherwise. * - * @example {{{ - * // Returns Some(HTTP) because the partial function covers the case. - * Some("http").collect({case "http" => "HTTP"}) + * @example {{{ + * // Returns Some(HTTP) because the partial function covers the case. + * Some("http").collect({case "http" => "HTTP"}) * - * // Returns None because the partial function doesn't cover the case. - * Some("ftp").collect({case "http" => "HTTP"}) + * // Returns None because the partial function doesn't cover the case. + * Some("ftp").collect({case "http" => "HTTP"}) * - * // Returns None because None is passed to the collect method. - * None.collect({case value => value}) - * }}} + * // Returns None because None is passed to the collect method. + * None.collect({case value => value}) + * }}} * * @param pf the partial function. * @return the result of applying `pf` to this $option's From 14fa7bef120cbb996d042daba6095530167c49ed Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 1 Jul 2014 16:19:34 +0200 Subject: [PATCH 367/826] SI-8708 Fix pickling of LOCAL_CHILD child of sealed classes When a sealed class or trait has local children, they are not pickled in as part of the children of the symbol (introduced in 12a2b3b to fix Aladdin bug 1055). Instead the compiler adds a single child class named LOCAL_CHILD. The parents of its ClassInfoType were wrong: the first parent should be a class. For sealed traits, we were using the trait itself. Also, the LOCAL_CHILD dummy class was entered as a member of its enclosing class, which is wrong: it represents a local (non-member) class, and it's a synthetic dummy anyway. --- .../tools/nsc/symtab/classfile/Pickler.scala | 11 ++++- .../reflect/internal/pickling/UnPickler.scala | 42 ++++++++++++++++--- test/files/neg/aladdin1055.check | 7 ++++ test/files/neg/aladdin1055.flags | 1 + test/files/neg/aladdin1055/A.scala | 6 +++ test/files/neg/aladdin1055/Test_1.scala | 5 +++ test/files/pos/t8708/Either_1.scala | 6 +++ test/files/pos/t8708/Test_2.scala | 13 ++++++ test/files/run/t8708_b.check | 8 ++++ test/files/run/t8708_b/A_1.scala | 8 ++++ test/files/run/t8708_b/Test_2.scala | 21 ++++++++++ 11 files changed, 122 insertions(+), 6 deletions(-) create mode 100644 test/files/neg/aladdin1055.check create mode 100644 test/files/neg/aladdin1055.flags create mode 100644 test/files/neg/aladdin1055/A.scala create mode 100644 test/files/neg/aladdin1055/Test_1.scala create mode 100644 test/files/pos/t8708/Either_1.scala create mode 100644 test/files/pos/t8708/Test_2.scala create mode 100644 test/files/run/t8708_b.check create mode 100644 test/files/run/t8708_b/A_1.scala create mode 100644 test/files/run/t8708_b/Test_2.scala diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala index 592c5497b552..34c5a899b74b 100644 --- a/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala +++ b/src/compiler/scala/tools/nsc/symtab/classfile/Pickler.scala @@ -186,7 +186,16 @@ abstract class Pickler extends SubComponent { val (locals, globals) = sym.children partition (_.isLocalClass) val children = if (locals.isEmpty) globals - else globals + sym.newClassWithInfo(tpnme.LOCAL_CHILD, List(sym.tpe), EmptyScope, pos = sym.pos) + else { + // The LOCAL_CHILD was introduced in 12a2b3b to fix Aladdin bug 1055. When a sealed + // class/trait has local subclasses, a single class symbol is added + // as pickled child (instead of a reference to the anonymous class; that was done + // initially, but seems not to work, as the bug shows). + // Adding the LOCAL_CHILD is necessary to retain exhaustivity warnings under separate + // compilation. See test neg/aladdin1055. + val parents = (if (sym.isTrait) List(definitions.ObjectTpe) else Nil) ::: List(sym.tpe) + globals + sym.newClassWithInfo(tpnme.LOCAL_CHILD, parents, EmptyScope, pos = sym.pos) + } putChildren(sym, children.toList sortBy (_.sealedSortName)) } diff --git a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala index 64a1a4472282..b808666360a8 100644 --- a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala +++ b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala @@ -290,6 +290,25 @@ abstract class UnPickler { def pflags = flags & PickledFlags def finishSym(sym: Symbol): Symbol = { + /** + * member symbols (symbols owned by a class) are added to the class's scope, with a number + * of exceptions: + * + * (.) ... + * (1) `local child` represents local child classes, see comment in Pickler.putSymbol. + * Since it is not a member, it should not be entered in the owner's scope. + */ + def shouldEnterInOwnerScope = { + sym.owner.isClass && + sym != classRoot && + sym != moduleRoot && + !sym.isModuleClass && + !sym.isRefinementClass && + !sym.isTypeParameter && + !sym.isExistentiallyBound && + sym.rawname != tpnme.LOCAL_CHILD // (1) + } + markFlagsCompleted(sym)(mask = AllFlags) sym.privateWithin = privateWithin sym.info = ( @@ -302,8 +321,7 @@ abstract class UnPickler { newLazyTypeRefAndAlias(inforef, readNat()) } ) - if (sym.owner.isClass && sym != classRoot && sym != moduleRoot && - !sym.isModuleClass && !sym.isRefinementClass && !sym.isTypeParameter && !sym.isExistentiallyBound) + if (shouldEnterInOwnerScope) symScope(sym.owner) enter sym sym @@ -681,10 +699,24 @@ abstract class UnPickler { private val p = phase protected def completeInternal(sym: Symbol) : Unit = try { val tp = at(i, () => readType(sym.isTerm)) // after NMT_TRANSITION, revert `() => readType(sym.isTerm)` to `readType` - if (p ne null) - slowButSafeEnteringPhase(p) (sym setInfo tp) + + // This is a temporary fix allowing to read classes generated by an older, buggy pickler. + // See the generation of the LOCAL_CHILD class in Pickler.scala. In an earlier version, the + // pickler did not add the ObjectTpe superclass, it used a trait as the first parent. This + // tripped an assertion in AddInterfaces which checks that the first parent is not a trait. + // This workaround can probably be removed in 2.12, because the 2.12 compiler is supposed + // to only read classfiles generated by 2.12. + val fixLocalChildTp = if (sym.rawname == tpnme.LOCAL_CHILD) tp match { + case ClassInfoType(superClass :: traits, decls, typeSymbol) if superClass.typeSymbol.isTrait => + ClassInfoType(definitions.ObjectTpe :: superClass :: traits, decls, typeSymbol) + case _ => tp + } else tp + + if (p ne null) { + slowButSafeEnteringPhase(p)(sym setInfo fixLocalChildTp) + } if (currentRunId != definedAtRunId) - sym.setInfo(adaptToNewRunMap(tp)) + sym.setInfo(adaptToNewRunMap(fixLocalChildTp)) } catch { case e: MissingRequirementError => throw toTypeError(e) diff --git a/test/files/neg/aladdin1055.check b/test/files/neg/aladdin1055.check new file mode 100644 index 000000000000..41782ae987ee --- /dev/null +++ b/test/files/neg/aladdin1055.check @@ -0,0 +1,7 @@ +Test_1.scala:2: warning: match may not be exhaustive. +It would fail on the following input: (_ : this.) + def foo(t: A.T) = t match { + ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found +one error found diff --git a/test/files/neg/aladdin1055.flags b/test/files/neg/aladdin1055.flags new file mode 100644 index 000000000000..e8fb65d50c20 --- /dev/null +++ b/test/files/neg/aladdin1055.flags @@ -0,0 +1 @@ +-Xfatal-warnings \ No newline at end of file diff --git a/test/files/neg/aladdin1055/A.scala b/test/files/neg/aladdin1055/A.scala new file mode 100644 index 000000000000..862336e30cb1 --- /dev/null +++ b/test/files/neg/aladdin1055/A.scala @@ -0,0 +1,6 @@ +object A { + sealed trait T { def f: Int } + class TT extends T { def f = 0 } + + def foo = new T { def f = 1 } // local subclass of sealed trait T +} diff --git a/test/files/neg/aladdin1055/Test_1.scala b/test/files/neg/aladdin1055/Test_1.scala new file mode 100644 index 000000000000..39d9b1dc980d --- /dev/null +++ b/test/files/neg/aladdin1055/Test_1.scala @@ -0,0 +1,5 @@ +object Test { + def foo(t: A.T) = t match { + case a: A.TT => 0 + } +} diff --git a/test/files/pos/t8708/Either_1.scala b/test/files/pos/t8708/Either_1.scala new file mode 100644 index 000000000000..000ed6e7c283 --- /dev/null +++ b/test/files/pos/t8708/Either_1.scala @@ -0,0 +1,6 @@ +sealed trait \/[+A, +B] + +sealed trait EitherT[F[+_], +A, +B] +object EitherT { + def apply[F[+_], A, B](a: F[A \/ B]): EitherT[F, A, B] = new EitherT[F, A, B] { val run = a } +} diff --git a/test/files/pos/t8708/Test_2.scala b/test/files/pos/t8708/Test_2.scala new file mode 100644 index 000000000000..d0e56b9a3743 --- /dev/null +++ b/test/files/pos/t8708/Test_2.scala @@ -0,0 +1,13 @@ +import scala.language.higherKinds + +trait ClientTypes[M[+_]] { + final type Context[+A] = EitherT[M, String, A] + object Context { + def apply[A](ca: M[String \/ A]): Context[A] = EitherT[M, String, A](ca) + } + + final type StatefulContext[+A] = EitherT[Context, String, A] + object StatefulContext { + def apply[A](state: Context[String \/ A]): StatefulContext[A] = ??? + } +} diff --git a/test/files/run/t8708_b.check b/test/files/run/t8708_b.check new file mode 100644 index 000000000000..30be62a3078e --- /dev/null +++ b/test/files/run/t8708_b.check @@ -0,0 +1,8 @@ +Scope{ + def : ; + sealed abstract trait T extends ; + def foo: +} +Scope{ + def f: +} diff --git a/test/files/run/t8708_b/A_1.scala b/test/files/run/t8708_b/A_1.scala new file mode 100644 index 000000000000..e767420f9e88 --- /dev/null +++ b/test/files/run/t8708_b/A_1.scala @@ -0,0 +1,8 @@ +package p + +class C { + + sealed trait T { def f: Int } + + def foo: T = new T { def f = 1 } +} diff --git a/test/files/run/t8708_b/Test_2.scala b/test/files/run/t8708_b/Test_2.scala new file mode 100644 index 000000000000..c9784906090b --- /dev/null +++ b/test/files/run/t8708_b/Test_2.scala @@ -0,0 +1,21 @@ +import scala.tools.partest._ +import java.io.{Console => _, _} + +object Test extends DirectTest { + + override def extraSettings: String = "-usejavacp -cp " + testOutput.path + + override def code = "" + + override def show(): Unit = { + val g = newCompiler() + withRun(g)(r => { + val c = g.rootMirror.getRequiredClass("p.C") + println(c.info.decls) + val t = c.info.member(g.newTypeName("T")) + // this test ensrues that the dummy class symbol is not entered in the + // scope of trait T during unpickling. + println(t.info.decls) + }) + } +} From 532ef331eb050454d33a3063b48b581db874d57a Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Mon, 7 Jul 2014 10:14:57 +0200 Subject: [PATCH 368/826] Restore reporter forwarders in CompilationUnit Deprecate them so that we can remove them in a couple of 2.11.x releases. Plenty of plugins were probably using `unit.error` et al. The continuations plugin was, for one (remedying this with pending PR). --- src/compiler/scala/tools/nsc/CompilationUnits.scala | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/src/compiler/scala/tools/nsc/CompilationUnits.scala b/src/compiler/scala/tools/nsc/CompilationUnits.scala index 1ad206f51953..f23bca77cd4f 100644 --- a/src/compiler/scala/tools/nsc/CompilationUnits.scala +++ b/src/compiler/scala/tools/nsc/CompilationUnits.scala @@ -123,8 +123,21 @@ trait CompilationUnits { global: Global => */ val icode: LinkedHashSet[icodes.IClass] = new LinkedHashSet + @deprecated("Call global.reporter.echo directly instead.", "2.11.2") + final def echo(pos: Position, msg: String): Unit = reporter.echo(pos, msg) + @deprecated("Call global.reporter.error (or typer.context.error) directly instead.", "2.11.2") + final def error(pos: Position, msg: String): Unit = reporter.error(pos, msg) + @deprecated("Call global.reporter.warning (or typer.context.warning) directly instead.", "2.11.2") + final def warning(pos: Position, msg: String): Unit = reporter.warning(pos, msg) + + @deprecated("Call global.currentRun.reporting.deprecationWarning directly instead.", "2.11.2") + final def deprecationWarning(pos: Position, msg: String): Unit = currentRun.reporting.deprecationWarning(pos, msg) + @deprecated("Call global.currentRun.reporting.uncheckedWarning directly instead.", "2.11.2") + final def uncheckedWarning(pos: Position, msg: String): Unit = currentRun.reporting.uncheckedWarning(pos, msg) + // called by ScalaDocAnalyzer, overridden by the IDE (in Reporter) // TODO: don't use reporter to communicate comments from parser to IDE! + @deprecated("This method will be removed.", "2.11.2") final def comment(pos: Position, msg: String): Unit = reporter.comment(pos, msg) From 4c2217e8a0e67ccd675aa4f1be253f87697c9025 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 10 Jun 2014 10:55:06 +0200 Subject: [PATCH 369/826] Minor cleanups and comments in GenBCode --- .../tools/nsc/backend/jvm/BCodeHelpers.scala | 3 ++ .../tools/nsc/backend/jvm/BCodeTypes.scala | 46 +++++++++++++++---- .../scala/tools/nsc/backend/jvm/BTypes.scala | 22 +++++++-- .../scala/tools/nsc/backend/jvm/GenASM.scala | 3 ++ .../tools/nsc/backend/jvm/GenBCode.scala | 2 +- .../scala/reflect/internal/Symbols.scala | 28 ++++++++--- 6 files changed, 83 insertions(+), 21 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala index 51bfdf002720..07890dd5f872 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala @@ -460,6 +460,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { // Can't call .toInterface (at this phase) or we trip an assertion. // See PackratParser#grow for a method which fails with an apparent mismatch // between "object PackratParsers$class" and "trait PackratParsers" + // TODO @lry do we have a test for that? if (sym.isImplClass) { // pos/spec-List.scala is the sole failure if we don't check for NoSymbol val traitSym = sym.owner.info.decl(tpnme.interfaceName(sym.name)) @@ -469,6 +470,8 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { } } + // TODO @lry: code duplication between here and method asmClassType. + assert(hasInternalName(sym), s"Invoked for a symbol lacking JVM internal name: ${sym.fullName}") assert(!phantomTypeMap.contains(sym), "phantom types not supposed to reach here.") diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala index 62dfb4917d09..22cb189c70a5 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala @@ -21,8 +21,9 @@ abstract class BCodeTypes extends BCodeIdiomatic { import global._ import bTypes._ - // when compiling the Scala library, some assertions don't hold (e.g., scala.Boolean has null superClass although it's not an interface) - val isCompilingStdLib = !(settings.sourcepath.isDefault) + // Used only for assertions. When compiling the Scala library, some assertions don't hold + // (e.g., scala.Boolean has null superClass although it's not an interface) + private val isCompilingStdLib = !(settings.sourcepath.isDefault) // special names var StringReference : ClassBType = null @@ -175,12 +176,21 @@ abstract class BCodeTypes extends BCodeIdiomatic { // ------------------------------------------------ /** - * TODO @lry should probably be a map form ClassBType to Tracked + * Type information for classBTypes. + * + * TODO rename Tracked */ - val exemplars = new java.util.concurrent.ConcurrentHashMap[BType, Tracked] + val exemplars = new java.util.concurrent.ConcurrentHashMap[ClassBType, Tracked] /** * Maps class symbols to their corresponding `Tracked` instance. + * + * This map is only used during the first backend phase (Worker1) where ClassDef trees are + * transformed into ClassNode asm trees. In this phase, ClassBTypes and their Tracked are created + * and added to the `exemplars` map. The `symExemplars` map is only used to know if a symbol has + * already been visited. + * + * TODO move this map to the builder class. it's only used during building. can be gc'd with the builder. */ val symExemplars = new java.util.concurrent.ConcurrentHashMap[Symbol, Tracked] @@ -313,7 +323,7 @@ abstract class BCodeTypes extends BCodeIdiomatic { final def isDeprecated(sym: Symbol): Boolean = { sym.annotations exists (_ matches definitions.DeprecatedAttr) } /* must-single-thread */ - final def hasInternalName(sym: Symbol) = { sym.isClass || (sym.isModule && !sym.isMethod) } + final def hasInternalName(sym: Symbol) = sym.isClass || sym.isModuleNotMethod /* must-single-thread */ def getSuperInterfaces(csym: Symbol): List[Symbol] = { @@ -702,6 +712,10 @@ abstract class BCodeTypes extends BCodeIdiomatic { var x = ics while (x ne NoSymbol) { assert(x.isClass, s"not a class symbol: ${x.fullName}") + // Uses `rawowner` because `owner` reflects changes in the owner chain due to flattening. + // The owner chain of a class only contains classes. This is because the lambdalift phase + // changes the `rawowner` destructively to point to the enclosing class. Before, the owner + // might be for example a method. val isInner = !x.rawowner.isPackageClass if (isInner) { chain ::= x @@ -794,14 +808,23 @@ abstract class BCodeTypes extends BCodeIdiomatic { * must-single-thread */ def javaFlags(sym: Symbol): Int = { - // constructors of module classes should be private - // PP: why are they only being marked private at this stage and not earlier? + // constructors of module classes should be private. introduced in b06edbc, probably to prevent + // creating module instances from java. for nested modules, the constructor needs to be public + // since they are created by the outer class and stored in a field. a java client can create + // new instances via outerClassInstance.new InnerModuleClass$(). + // TODO: do this early, mark the symbol private. val privateFlag = sym.isPrivate || (sym.isPrimaryConstructor && isTopLevelModule(sym.owner)) - // Final: the only fields which can receive ACC_FINAL are eager vals. - // Neither vars nor lazy vals can, because: + // Symbols marked in source as `final` have the FINAL flag. (In the past, the flag was also + // added to modules and module classes, not anymore since 296b706). + // Note that the presence of the `FINAL` flag on a symbol does not correspond 1:1 to emitting + // ACC_FINAL in bytecode. + // + // Top-level modules are marked ACC_FINAL in bytecode (even without the FINAL flag). Nested + // objects don't get the flag to allow overriding (under -Yoverride-objects, SI-5676). // + // For fields, only eager val fields can receive ACC_FINAL. vars or lazy vals can't: // Source: http://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html#jls-17.5.3 // "Another problem is that the specification allows aggressive // optimization of final fields. Within a thread, it is permissible to @@ -818,7 +841,6 @@ abstract class BCodeTypes extends BCodeIdiomatic { // we can exclude lateFINAL. Such symbols are eligible for inlining, but to // avoid breaking proxy software which depends on subclassing, we do not // emit ACC_FINAL. - // Nested objects won't receive ACC_FINAL in order to allow for their overriding. val finalFlag = ( (((sym.rawflags & symtab.Flags.FINAL) != 0) || isTopLevelModule(sym)) @@ -845,6 +867,10 @@ abstract class BCodeTypes extends BCodeIdiomatic { if (sym.isVarargsMethod) ACC_VARARGS else 0, if (sym.hasFlag(symtab.Flags.SYNCHRONIZED)) ACC_SYNCHRONIZED else 0 ) + // TODO @lry should probably also check / add "deprectated" + // all call sites of "javaFlags" seem to check for deprecation rigth after. + // Exception: the call below in javaFieldFlags. However, the caller of javaFieldFlags then + // does the check. } /* diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala index 5b0fa6f7a8f8..aac4f9cbfc94 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala @@ -235,10 +235,24 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { /** * Class or Interface type. * - * Classes are represented using their name as a slice of the `chrs` array. This representation is - * efficient because the JVM class name is initially created using `classSymbol.javaBinaryName`. - * This already adds the necessary string to the `chrs` array, so it makes sense to reuse the same - * name table in the backend. + * The information for creating a ClassBType (superClass, interfaces, etc) is obtained + * - either from a ClassSymbol, for classes being compiled or referenced from source (see + * BCodeTypes) + * - or, during inlining, from ASM ClassNodes that are parsed from class files. + * + * The class name is represented as a slice of the `chrs` array. This representation is efficient + * because the JVM class name is obtained through `classSymbol.javaBinaryName`. This already adds + * the necessary string to the `chrs` array, so it makes sense to reuse the same name table in the + * backend. + * + * Not a case class because that would expose the constructor that takes (offset, length) + * parameters (I didn't find a way to make it private, also the factory in the companion). + * + * @param offset See below + * @param length The class name is represented as offset and length in the `chrs` array. + * The (public) constructors of ClassBType take a BTypeName, which are + * hash-consed. This ensures that two ClassBType instances for the same name + * have the same offset and length. * * Not a case class because that would expose the (Int, Int) constructor (didn't find a way to * make it private, also the factory in the companion). diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala index 988c04f514f9..ce7e7c49ffc6 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala @@ -636,6 +636,9 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { innerSym.rawname + innerSym.moduleSuffix // add inner classes which might not have been referenced yet + // TODO @lry according to the spec, all nested classes should be added, also local and + // anonymous. This seems to add only member classes - or not? it's exitingErasure, so maybe + // local / anonymous classes have been lifted by lambdalift. are they in the "decls" though? exitingErasure { for (sym <- List(csym, csym.linkedClassOfClass); m <- sym.info.decls.map(innerClassSymbolFor) if m.isClass) innerClassBuffer += m diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala index 9b292fee7fb0..6b192556d979 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala @@ -271,7 +271,7 @@ abstract class GenBCode extends BCodeSyncAndTry { override def run() { arrivalPos = 0 // just in case - scalaPrimitives.init + scalaPrimitives.init() initBCodeTypes() // initBytecodeWriter invokes fullName, thus we have to run it before the typer-dependent thread is activated. diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala index 2ce54d225911..cc750fb88a64 100644 --- a/src/reflect/scala/reflect/internal/Symbols.scala +++ b/src/reflect/scala/reflect/internal/Symbols.scala @@ -1099,13 +1099,28 @@ trait Symbols extends api.Symbols { self: SymbolTable => // ------ owner attribute -------------------------------------------------------------- - /** In general when seeking the owner of a symbol, one should call `owner`. - * The other possibilities include: - * - call `safeOwner` if it is expected that the target may be NoSymbol - * - call `assertOwner` if it is an unrecoverable error if the target is NoSymbol + /** + * The owner of a symbol. Changes over time to adapt to the structure of the trees: + * - Up to lambdalift, the owner is the lexically enclosing definition. For definitions + * in a local block, the owner is also the next enclosing definition. + * - After lambdalift, all local method and class definitions (those not owned by a class + * or package class) change their owner to the enclosing class. This is done through + * a destructive "sym.owner = sym.owner.enclClass". The old owner is saved by + * saveOriginalOwner for the backend (needed to generate the EnclosingMethod attribute). + * - After flatten, all classes are owned by a PackageClass. This is done through a + * phase check (if after flatten) in the (overridden) method "def owner" in + * ModuleSymbol / ClassSymbol. The `rawowner` field is not modified. + * - Owners are also changed in other situations, for example when moving trees into a new + * lexical context, e.g. in the named/default arguments tranformation, or when translating + * extension method definitions. + * + * In general when seeking the owner of a symbol, one should call `owner`. + * The other possibilities include: + * - call `safeOwner` if it is expected that the target may be NoSymbol + * - call `assertOwner` if it is an unrecoverable error if the target is NoSymbol * - * `owner` behaves like `safeOwner`, but logs NoSymbol.owner calls under -Xdev. - * `assertOwner` aborts compilation immediately if called on NoSymbol. + * `owner` behaves like `safeOwner`, but logs NoSymbol.owner calls under -Xdev. + * `assertOwner` aborts compilation immediately if called on NoSymbol. */ def owner: Symbol = { if (Statistics.hotEnabled) Statistics.incCounter(ownerCount) @@ -2811,6 +2826,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => override def owner = { if (Statistics.hotEnabled) Statistics.incCounter(ownerCount) + // a module symbol may have the lateMETHOD flag after refchecks, see isModuleNotMethod if (!isMethod && needsFlatClasses) rawowner.owner else rawowner } From 91c7be16288e060aadb8aa7b0315b12e98621f02 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 10 Jun 2014 10:59:51 +0200 Subject: [PATCH 370/826] Comment summarizing the JVM spec for InnerClass / EnclosingMethod --- .../scala/tools/nsc/backend/jvm/BTypes.scala | 199 ++++++++++++++++++ 1 file changed, 199 insertions(+) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala index aac4f9cbfc94..508c58539373 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala @@ -232,6 +232,205 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { } } + /** + * InnerClass and EnclosingMethod attributes (EnclosingMethod is displayed as OUTERCLASS in asm). + * + * In this summary, "class" means "class or interface". + * + * JLS: http://docs.oracle.com/javase/specs/jls/se8/html/index.html + * JVMS: http://docs.oracle.com/javase/specs/jvms/se8/html/index.html + * + * Terminology + * ----------- + * + * - Nested class (JLS 8): class whose declaration occurs within the body of another class + * + * - Top-level class (JLS 8): non-nested class + * + * - Inner class (JLS 8.1.3): nested class that is not (explicitly or implicitly) static + * + * - Member class (JLS 8.5): class directly enclosed in the body of a class (and not, for + * example, defined in a method). Member classes cannot be anonymous. May be static. + * + * - Local class (JLS 14.3): nested, non-anonymous class that is not a member of a class + * - cannot be static (therefore they are "inner" classes) + * - can be defined in a method, a constructor or in an initializer block + * + * - Initializer block (JLS 8.6 / 8.7): block of statements in a java class + * - static initializer: executed before constructor body + * - instance initializer: exectued when class is initialized (instance creation, static + * field access, ...) + * + * + * InnerClass + * ---------- + * + * The JVMS 4.7.6 requires an entry for every class mentioned in a CONSTANT_Class_info in the + * constant pool (CP) that is not a member of a package (JLS 7.1). + * + * The JLS 13.1, points 9. / 10. requires: a class must reference (in the CP) + * - its immediately enclosing class + * - all of its member classes + * - all local and anonymous classes that appear elsewhere (method, constructor, initializer + * block, field initializer) + * + * In a comment, the 4.7.6 spec says: this implies an entry in the InnerClass attribute for + * - All enclosing classes (except the outermost, which is top-level) + * - My comment: not sure how this is implied, below (*) a Java counter-example. + * In any case, the Java compiler seems to add all enclosing classes, even if they are not + * otherwise mentioned in the CP. So we should do the same. + * - All nested classes (including anonymous and local, but not transitively) + * + * Fields in the InnerClass entries: + * - inner class: the (nested) class C we are talking about + * - outer class: the class of which C is a member. Has to be null for non-members, i.e. for + * local and anonymous classes. + * - inner name: A string with the simple name of the inner class. Null for anonymous classes. + * - flags: access property flags, details in JVMS, table in 4.7.6. + * + * + * Note 1: when a nested class is present in the InnerClass attribute, all of its enclosing + * classes have to be present as well (by the rules above). Example: + * + * class Outer { class I1 { class I2 { } } } + * class User { Outer.I1.I2 foo() { } } + * + * The return type "Outer.I1.I2" puts "Outer$I1$I2" in the CP, therefore the class is added to the + * InnerClass attribute. For this entry, the "outer class" field will be "Outer$I1". This in turn + * adds "Outer$I1" to the CP, which requires adding that class to the InnerClass attribute. + * (For local / anonymous classes this would not be the case, since the "outer class" attribute + * would be empty. However, no class (other than the enclosing class) can refer to them, as they + * have no name.) + * + * In the current implementation of the Scala compiler, when adding a class to the InnerClass + * attribute, all of its enclosing classes will be added as well. Javac seems to do the same, + * see (*). + * + * + * Note 2: If a class name is mentioned only in a CONSTANT_Utf8_info, but not in a + * CONSTANT_Class_info, the JVMS does not require an entry in the InnerClass attribute. However, + * the Java compiler seems to add such classes anyway. For example, when using an annotation, the + * annotation class is stored as a CONSTANT_Utf8_info in the CP: + * + * @O.Ann void foo() { } + * + * adds "const #13 = Asciz LO$Ann;;" in the constant pool. The "RuntimeInvisibleAnnotations" + * attribute refers to that constant pool entry. Even though there is no other reference to + * `O.Ann`, the java compiler adds an entry for that class to the InnerClass attribute (which + * entails adding a CONSTANT_Class_info for the class). + * + * + * + * EnclosingMethod + * --------------- + * + * JVMS 4.7.7: the attribute must be present "if and only if it represents a local class + * or an anonymous class" (i.e. not for member classes). + * + * Fields: + * - class: the enclosing class + * - method: the enclosing method (or constructor). Null if the class is not enclosed by a + * method, i.e. for + * - local or anonymous classes defined in (static or non-static) initializer blocks + * - anonymous classes defined in initializer blocks or field initializers + * + * Note: the field is required for anonymous classes defined within local variable + * initializers (within a method), Java example below (**). + * + * Currently, the Scala compiler sets "method" to the class constructor for classes + * defined in initializer blocks or field initializers. This is probably OK, since the + * Scala compiler desugars these statements into to the primary constructor. + * + * + * (*) + * public class Test { + * void foo() { + * class Foo1 { + * // constructor statement block + * { + * class Foo2 { + * class Foo3 { } + * } + * } + * } + * } + * } + * + * The class file Test$1Foo1$1Foo2$Foo3 has no reference to the class Test$1Foo1, however it + * still contains an InnerClass attribute for Test$1Foo1. + * Maybe this is just because the Java compiler follows the JVMS comment ("InnerClasses + * information for each enclosing class"). + * + * + * (**) + * void foo() { + * // anonymous class defined in local variable initializer expression. + * Runnable x = true ? (new Runnable() { + * public void run() { return; } + * }) : null; + * } + * + * The EnclosingMethod attribute of the anonymous class mentions "foo" in the "method" field. + * + * + * Java Compatibility + * ------------------ + * + * In the InnerClass entry for classes in top-level modules, the "outer class" is emitted as the + * mirror class (or the existing companion class), i.e. C1 is nested in T (not T$). + * For classes nested in a nested object, the "outer class" is the module class: C2 is nested in T$N$ + * object T { + * class C1 + * object N { class C2 } + * } + * + * Reason: java compat. It's a "best effort" "solution". If you want to use "C1" from Java, you + * can write "T.C1", and the Java compiler will translate that to the classfile T$C1. + * + * If we would emit the "outer class" of C1 as "T$", then in Java you'd need to write "T$.C1" + * because the java compiler looks at the InnerClass attribute to find if an inner class exists. + * However, the Java compiler would then translate the '.' to '$' and you'd get the class name + * "T$$C1". This class file obviously does not exist. + * + * Directly using the encoded class name "T$C1" in Java does not work: since the classfile + * describes a nested class, the Java compiler hides it from the classpath and will report + * "cannot find symbol T$C1". This means that the class T.N.C2 cannot be referenced from a + * Java source file in any way. + * + * + * STATIC flag + * ----------- + * + * Java: static nested classes have the "static" flag in the InnerClass attribute. This is not the + * case for local classes defined within a static method, even though such classes, as they are + * defined in a static context, don't take an "outer" instance. + * Non-static nested classes (inner classes, including local classes defined in a non-static + * method) take an "outer" instance on construction. + * + * Scala: Explicitouter adds an "outer" parameter to nested classes, except for classes defined + * in a static context, i.e. when all outer classes are module classes. + * package p + * object O1 { + * class C1 // static + * object O2 { + * def f = { + * class C2 { // static + * class C3 // non-static, needs outer + * } + * } + * } + * } + * + * Int the InnerClass attribute, the `static` flag is added for all classes defined in a static + * context, i.e. also for C2. This is different than in Java. + * + * + * Mirror Classes + * -------------- + * + * TODO: innerclass attributes on mirror class, bean info class + */ + /** * Class or Interface type. * From 57de87e655820df9d016613badc13e3e86059417 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 10 Jun 2014 11:00:25 +0200 Subject: [PATCH 371/826] Remove unnessecary check when computing InnerClass attribute flags The final flag is computed correctly by javaFlags. --- .../scala/tools/nsc/backend/jvm/BCodeTypes.scala | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala index 22cb189c70a5..9b131cb1232f 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala @@ -755,12 +755,23 @@ abstract class BCodeTypes extends BCodeIdiomatic { innerSym.rawname + innerSym.moduleSuffix } - val flagsWithFinal: Int = mkFlags( + // TODO @lry compare with table in spec: for example, deprecated should not be there it seems. + // http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.6-300-D.1-D.1 + // including "deprecated" was added in the initial commit of GenASM, but it was never in GenJVM. + val flags: Int = mkFlags( + // TODO @lry adding "static" whenever the class is owned by a module seems wrong. + // class C { object O { class I } } + // here, I is marked static in the InnerClass attribute. But the I constructor takes an outer instance. + // was added in 0469d41 + // what should it be? check what would make sense for java reflection. + // member of top-level object should be static? how about anonymous / local class that has + // been lifted to a top-level object? + // member that is only nested in objects should be static? + // verify: will ICodeReader still work after that? the code was introduced because of icode reader. if (innerSym.rawowner.hasModuleFlag) asm.Opcodes.ACC_STATIC else 0, javaFlags(innerSym), if (isDeprecated(innerSym)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo-access flag ) & (INNER_CLASSES_FLAGS | asm.Opcodes.ACC_DEPRECATED) - val flags = if (innerSym.isModuleClass) flagsWithFinal & ~asm.Opcodes.ACC_FINAL else flagsWithFinal // For SI-5676, object overriding. val jname = innerSym.javaBinaryName.toString // never null val oname = { // null when method-enclosed From 1bed39a1cb2be13cb26a038dfd1649964063c498 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 10 Jun 2014 11:17:47 +0200 Subject: [PATCH 372/826] Pattern matching on ClassBType extracts the inernalName --- .../scala/tools/nsc/backend/jvm/BTypes.scala | 49 ++++++++++--------- 1 file changed, 27 insertions(+), 22 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala index 508c58539373..15bc0685336c 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala @@ -43,9 +43,9 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { case FLOAT => "F" case LONG => "J" case DOUBLE => "D" - case c @ ClassBType(_, _) => "L" + c.internalName + ";" - case ArrayBType(component) => "[" + component - case MethodBType(args, res) => "(" + args.mkString + ")" + res + case ClassBType(internalName) => "L" + internalName + ";" + case ArrayBType(component) => "[" + component + case MethodBType(args, res) => "(" + args.mkString + ")" + res } /** @@ -160,9 +160,9 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { case FLOAT => asm.Type.FLOAT_TYPE case LONG => asm.Type.LONG_TYPE case DOUBLE => asm.Type.DOUBLE_TYPE - case c @ ClassBType(_, _) => asm.Type.getObjectType(c.internalName) // (*) - case a @ ArrayBType(_) => asm.Type.getObjectType(a.descriptor) - case m @ MethodBType(_, _) => asm.Type.getMethodType(m.descriptor) + case ClassBType(internalName) => asm.Type.getObjectType(internalName) // see (*) above + case a: ArrayBType => asm.Type.getObjectType(a.descriptor) + case m: MethodBType => asm.Type.getMethodType(m.descriptor) } def asRefBType : RefBType = this.asInstanceOf[RefBType] @@ -227,8 +227,8 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { * This can be verified for example using javap or ASMifier. */ def classOrArrayType: String = this match { - case c: ClassBType => c.internalName - case a: ArrayBType => a.descriptor + case ClassBType(internalName) => internalName + case a: ArrayBType => a.descriptor } } @@ -458,21 +458,23 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { */ class ClassBType private(val offset: Int, val length: Int) extends RefBType { /** - * Construct a ClassBType for a given (intenred) class name. + * Construct a ClassBType from the (intenred) internal name of a class. * - * @param n The class name as a slice of the `chrs` array, without the surrounding 'L' and ';'. - * Note that `classSymbol.javaBinaryName` returns exactly such a name. + * @param internalName The internal name as a slice of the `chrs` array. The internal name does + * not have the surrounding 'L' and ';'. Note that + * `classSymbol.javaBinaryName` returns exactly such a name. */ - def this(n: BTypeName) = this(n.start, n.length) + def this(internalName: BTypeName) = this(internalName.start, internalName.length) /** - * Construct a ClassBType for a given java class name. + * Construct a ClassBType from the internal name of a class. * - * @param s A class name of the form "java/lang/String", without the surrounding 'L' and ';'. + * @param internalName The internal name of a class has the form "java/lang/String", without the + * surrounding 'L' and ';'. */ - def this(s: String) = this({ - assert(!(s.head == 'L' && s.last == ';'), s"Descriptor instead of internal name: $s") - createNewName(s) + def this(internalName: String) = this({ + assert(!(internalName.head == 'L' && internalName.last == ';'), s"Descriptor instead of internal name: $internalName") + createNewName(internalName) }) /** @@ -490,7 +492,7 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { * Custom equals / hashCode are needed because this is not a case class. */ override def equals(o: Any): Boolean = (this eq o.asInstanceOf[Object]) || (o match { - case ClassBType(`offset`, `length`) => true + case c: ClassBType => c.offset == this.offset && c.length == this.length case _ => false }) @@ -504,12 +506,15 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { } object ClassBType { - def apply(n: BTypeName): ClassBType = new ClassBType(n) - def apply(s: String): ClassBType = new ClassBType(s) + def apply(internalName: BTypeName): ClassBType = new ClassBType(internalName) + def apply(internalName: String): ClassBType = new ClassBType(internalName) - def unapply(c: ClassBType): Option[(Int, Int)] = + /** + * Pattern matching on a ClassBType extracts the `internalName` of the class. + */ + def unapply(c: ClassBType): Option[String] = if (c == null) None - else Some((c.offset, c.length)) + else Some(c.internalName) } case class ArrayBType(componentType: BType) extends RefBType { From 0ccdb151ffe9caa9eae7d01a4f2eacc87fa8f5ff Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 10 Jun 2014 11:21:13 +0200 Subject: [PATCH 373/826] Clean up and document some usages of flags in the backend --- .../nsc/backend/jvm/BCodeBodyBuilder.scala | 2 +- .../nsc/backend/jvm/BCodeSkelBuilder.scala | 2 +- .../tools/nsc/backend/jvm/BCodeTypes.scala | 50 ++++++++++--- .../tools/nsc/backend/jvm/GenBCode.scala | 2 +- .../tools/nsc/symtab/SymbolLoaders.scala | 41 +++++++--- .../scala/tools/nsc/transform/Flatten.scala | 11 ++- .../scala/tools/nsc/transform/LazyVals.scala | 4 +- .../scala/reflect/internal/Symbols.scala | 75 +++++++++++++++---- .../scala/reflect/runtime/SymbolLoaders.scala | 11 ++- 9 files changed, 154 insertions(+), 44 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index bffa4bc51daf..b79cf01f41df 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -977,7 +977,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { if (!isModuleInitialized && jMethodName == INSTANCE_CONSTRUCTOR_NAME && jname == INSTANCE_CONSTRUCTOR_NAME && - isStaticModule(siteSymbol)) { + isStaticModuleClass(siteSymbol)) { isModuleInitialized = true mnode.visitVarInsn(asm.Opcodes.ALOAD, 0) mnode.visitFieldInsn( diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala index effc68c5e317..f8ecb8e64358 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala @@ -95,7 +95,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { claszSymbol = cd.symbol isCZParcelable = isAndroidParcelableClass(claszSymbol) - isCZStaticModule = isStaticModule(claszSymbol) + isCZStaticModule = isStaticModuleClass(claszSymbol) isCZRemote = isRemote(claszSymbol) thisName = internalName(claszSymbol) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala index 9b131cb1232f..b373f8d74d72 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala @@ -627,20 +627,52 @@ abstract class BCodeTypes extends BCodeIdiomatic { false } - /* + /** * must-single-thread + * + * True for module classes of package level objects. The backend will generate a mirror class for + * such objects. */ - def isTopLevelModule(sym: Symbol): Boolean = { - exitingPickler { sym.isModuleClass && !sym.isImplClass && !sym.isNestedClass } + def isTopLevelModuleClass(sym: Symbol): Boolean = exitingPickler { + // phase travel to pickler required for isNestedClass (looks at owner) + val r = sym.isModuleClass && !sym.isNestedClass + // The mixin phase adds the `lateMODULE` flag to trait implementation classes. Since the flag + // is late, it should not be visible here inside the time travel. We check this. + if (r) assert(!sym.isImplClass, s"isModuleClass should be false for impl class $sym") + r } - /* + /** * must-single-thread + * + * True for module classes of modules that are top-level or owned only by objects. Module classes + * for such objects will get a MODULE$ flag and a corresponding static initializer. */ - def isStaticModule(sym: Symbol): Boolean = { - sym.isModuleClass && !sym.isImplClass && !sym.isLifted + def isStaticModuleClass(sym: Symbol): Boolean = { + /* The implementation of this method is tricky because it is a source-level property. Various + * phases changed the symbol's properties in the meantime. + * + * (1) Phase travel to to pickler is required to exclude implementation classes; they have the + * lateMODULEs after mixin, so isModuleClass would be true. + * + * (2) We cannot use `sym.isStatic` because lambdalift modified (destructively) the owner. For + * example, in + * object T { def f { object U } } + * the owner of U is T, so UModuleClass.isStatic is true. Phase travel does not help here. + * So we basically re-implement `sym.isStaticOwner`, but using the original owner chain. + */ + + def isOriginallyStaticOwner(sym: Symbol): Boolean = { + sym.isPackageClass || sym.isModuleClass && isOriginallyStaticOwner(sym.originalOwner) + } + + exitingPickler { // (1) + sym.isModuleClass && + isOriginallyStaticOwner(sym.originalOwner) // (2) + } } + // --------------------------------------------------------------------- // ---------------- InnerClasses attribute (JVMS 4.7.6) ---------------- // --------------------------------------------------------------------- @@ -743,7 +775,7 @@ abstract class BCodeTypes extends BCodeIdiomatic { null else { val outerName = innerSym.rawowner.javaBinaryName - if (isTopLevelModule(innerSym.rawowner)) nme.stripModuleSuffix(outerName) + if (isTopLevelModuleClass(innerSym.rawowner)) nme.stripModuleSuffix(outerName) else outerName } } @@ -825,7 +857,7 @@ abstract class BCodeTypes extends BCodeIdiomatic { // new instances via outerClassInstance.new InnerModuleClass$(). // TODO: do this early, mark the symbol private. val privateFlag = - sym.isPrivate || (sym.isPrimaryConstructor && isTopLevelModule(sym.owner)) + sym.isPrivate || (sym.isPrimaryConstructor && isTopLevelModuleClass(sym.owner)) // Symbols marked in source as `final` have the FINAL flag. (In the past, the flag was also // added to modules and module classes, not anymore since 296b706). @@ -854,7 +886,7 @@ abstract class BCodeTypes extends BCodeIdiomatic { // emit ACC_FINAL. val finalFlag = ( - (((sym.rawflags & symtab.Flags.FINAL) != 0) || isTopLevelModule(sym)) + (((sym.rawflags & symtab.Flags.FINAL) != 0) || isTopLevelModuleClass(sym)) && !sym.enclClass.isInterface && !sym.isClassConstructor && !sym.isMutable // lazy vals and vars both diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala index 6b192556d979..af5d01458ada 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala @@ -165,7 +165,7 @@ abstract class GenBCode extends BCodeSyncAndTry { // -------------- mirror class, if needed -------------- val mirrorC = - if (isStaticModule(claszSymbol) && isTopLevelModule(claszSymbol)) { + if (isTopLevelModuleClass(claszSymbol)) { if (claszSymbol.companionClass == NoSymbol) { mirrorCodeGen.genMirrorClass(claszSymbol, cunit) } else { diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala index 447fa66ae4ea..82c2a4d6edee 100644 --- a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala +++ b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala @@ -240,6 +240,12 @@ abstract class SymbolLoaders { } } + private def phaseBeforeRefchecks: Phase = { + var resPhase = phase + while (resPhase.refChecked) resPhase = resPhase.prev + resPhase + } + /** * Load contents of a package */ @@ -248,19 +254,24 @@ abstract class SymbolLoaders { protected def doComplete(root: Symbol) { assert(root.isPackageClass, root) - root.setInfo(new PackageClassInfoType(newScope, root)) - - if (!root.isRoot) { - for (classRep <- classpath.classes) { - initializeFromClassPath(root, classRep) - } - } - if (!root.isEmptyPackageClass) { - for (pkg <- classpath.packages) { - enterPackage(root, pkg.name, new PackageLoader(pkg)) + // Time travel to a phase before refchecks avoids an initialization issue. `openPackageModule` + // creates a module symbol and invokes invokes `companionModule` while the `infos` field is + // still null. This calls `isModuleNotMethod`, which forces the `info` if run after refchecks. + enteringPhase(phaseBeforeRefchecks) { + root.setInfo(new PackageClassInfoType(newScope, root)) + + if (!root.isRoot) { + for (classRep <- classpath.classes) { + initializeFromClassPath(root, classRep) + } } + if (!root.isEmptyPackageClass) { + for (pkg <- classpath.packages) { + enterPackage(root, pkg.name, new PackageLoader(pkg)) + } - openPackageModule(root) + openPackageModule(root) + } } } } @@ -290,7 +301,13 @@ abstract class SymbolLoaders { protected def doComplete(root: Symbol) { val start = if (Statistics.canEnable) Statistics.startTimer(classReadNanos) else null - classfileParser.parse(classfile, root) + + // Running the classfile parser after refchecks can lead to "illegal class file dependency" + // errors. More concretely, the classfile parser calls "sym.companionModule", which calls + // "isModuleNotMethod" on the companion. After refchecks, this method forces the info, which + // may run the classfile parser. This produces the error. + enteringPhase(phaseBeforeRefchecks)(classfileParser.parse(classfile, root)) + if (root.associatedFile eq NoAbstractFile) { root match { // In fact, the ModuleSymbol forwards its setter to the module class diff --git a/src/compiler/scala/tools/nsc/transform/Flatten.scala b/src/compiler/scala/tools/nsc/transform/Flatten.scala index c3fbfae322ff..fa53ef48b5b3 100644 --- a/src/compiler/scala/tools/nsc/transform/Flatten.scala +++ b/src/compiler/scala/tools/nsc/transform/Flatten.scala @@ -76,8 +76,17 @@ abstract class Flatten extends InfoTransform { for (sym <- decls) { if (sym.isTerm && !sym.isStaticModule) { decls1 enter sym - if (sym.isModule) + if (sym.isModule) { + // Nested, non-static moduls are transformed to methods. + assert(sym.isMethod, s"Non-static $sym should have the lateMETHOD flag from RefChecks") + // Note that module classes are not entered into the 'decls' of the ClassInfoType + // of the outer class, only the module symbols are. So the current loop does + // not visit module classes. Therefore we set the LIFTED flag here for module + // classes. + // TODO: should we also set the LIFTED flag for static, nested module classes? + // currently they don't get the flag, even though they are lifted to the package sym.moduleClass setFlag LIFTED + } } else if (sym.isClass) liftSymbol(sym) } diff --git a/src/compiler/scala/tools/nsc/transform/LazyVals.scala b/src/compiler/scala/tools/nsc/transform/LazyVals.scala index b71d14a04f5a..38671ebaaee4 100644 --- a/src/compiler/scala/tools/nsc/transform/LazyVals.scala +++ b/src/compiler/scala/tools/nsc/transform/LazyVals.scala @@ -192,13 +192,15 @@ abstract class LazyVals extends Transform with TypingTransformers with ast.TreeD def mkSlowPathDef(clazz: Symbol, lzyVal: Symbol, cond: Tree, syncBody: List[Tree], stats: List[Tree], retVal: Tree): Tree = { + // Q: is there a reason to first set owner to `clazz` (by using clazz.newMethod), and then + // changing it to lzyVal.owner very soon after? Could we just do lzyVal.owner.newMethod? val defSym = clazz.newMethod(nme.newLazyValSlowComputeName(lzyVal.name.toTermName), lzyVal.pos, STABLE | PRIVATE) defSym setInfo MethodType(List(), lzyVal.tpe.resultType) defSym.owner = lzyVal.owner debuglog(s"crete slow compute path $defSym with owner ${defSym.owner} for lazy val $lzyVal") if (bitmaps.contains(lzyVal)) bitmaps(lzyVal).map(_.owner = defSym) - val rhs: Tree = (gen.mkSynchronizedCheck(clazz, cond, syncBody, stats)).changeOwner(currentOwner -> defSym) + val rhs: Tree = gen.mkSynchronizedCheck(clazz, cond, syncBody, stats).changeOwner(currentOwner -> defSym) DefDef(defSym, addBitmapDefs(lzyVal, BLOCK(rhs, retVal))) } diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala index cc750fb88a64..b6cce4524b48 100644 --- a/src/reflect/scala/reflect/internal/Symbols.scala +++ b/src/reflect/scala/reflect/internal/Symbols.scala @@ -55,23 +55,29 @@ trait Symbols extends api.Symbols { self: SymbolTable => def newFreeTypeSymbol(name: TypeName, flags: Long = 0L, origin: String): FreeTypeSymbol = new FreeTypeSymbol(name, origin) initFlags flags - /** The original owner of a class. Used by the backend to generate - * EnclosingMethod attributes. + /** + * This map stores the original owner the the first time the owner of a symbol is re-assigned. + * The original owner of a symbol is needed in some places in the backend. Ideally, owners should + * be versioned like the type history. */ - val originalOwner = perRunCaches.newMap[Symbol, Symbol]() + private val originalOwnerMap = perRunCaches.newMap[Symbol, Symbol]() // TODO - don't allow the owner to be changed without checking invariants, at least // when under some flag. Define per-phase invariants for owner/owned relationships, // e.g. after flatten all classes are owned by package classes, there are lots and // lots of these to be declared (or more realistically, discovered.) - protected def saveOriginalOwner(sym: Symbol) { - if (originalOwner contains sym) () - else originalOwner(sym) = sym.rawowner + protected def saveOriginalOwner(sym: Symbol): Unit = { + // some synthetic symbols have NoSymbol as owner initially + if (sym.owner != NoSymbol) { + if (originalOwnerMap contains sym) () + else originalOwnerMap(sym) = sym.rawowner + } } + protected def originalEnclosingMethod(sym: Symbol): Symbol = { if (sym.isMethod || sym == NoSymbol) sym else { - val owner = originalOwner.getOrElse(sym, sym.rawowner) + val owner = sym.originalOwner if (sym.isLocalDummy) owner.enclClass.primaryConstructor else originalEnclosingMethod(owner) } @@ -757,8 +763,22 @@ trait Symbols extends api.Symbols { self: SymbolTable => * So "isModuleNotMethod" exists not for its achievement in * brevity, but to encapsulate the relevant condition. */ - def isModuleNotMethod = isModule && !isMethod - def isStaticModule = isModuleNotMethod && isStatic + def isModuleNotMethod = { + if (isModule) { + if (phase.refChecked) this.info // force completion to make sure lateMETHOD is there. + !isMethod + } else false + } + + // After RefChecks, the `isStatic` check is mostly redundant: all non-static modules should + // be methods (and vice versa). There's a corner case on the vice-versa with mixed-in module + // symbols: + // trait T { object A } + // object O extends T + // The module symbol A is cloned into T$impl (addInterfaces), and then cloned into O (mixin). + // Since the original A is not static, it's turned into a method. The clone in O however is + // static (owned by a module), but it's also a method. + def isStaticModule = isModuleNotMethod && isStatic final def isInitializedToDefault = !isType && hasAllFlags(DEFAULTINIT | ACCESSOR) final def isThisSym = isTerm && owner.thisSym == this @@ -909,10 +929,31 @@ trait Symbols extends api.Symbols { self: SymbolTable => ) final def isModuleVar = hasFlag(MODULEVAR) - /** Is this symbol static (i.e. with no outer instance)? - * Q: When exactly is a sym marked as STATIC? - * A: If it's a member of a toplevel object, or of an object contained in a toplevel object, or any number of levels deep. - * http://groups.google.com/group/scala-internals/browse_thread/thread/d385bcd60b08faf6 + /** + * Is this symbol static (i.e. with no outer instance)? + * Q: When exactly is a sym marked as STATIC? + * A: If it's a member of a toplevel object, or of an object contained in a toplevel object, or + * any number of levels deep. + * http://groups.google.com/group/scala-internals/browse_thread/thread/d385bcd60b08faf6 + * + * TODO: should this only be invoked on class / module symbols? because there's also `isStaticMember`. + * + * Note: the result of `isStatic` changes over time. + * - Lambdalift local definitions to the class level, the `owner` field is modified. + * object T { def foo { object O } } + * After lambdalift, the OModule.isStatic is true. + * + * - After flatten, nested classes are moved to the package level. Invoking `owner` on a + * class returns a package class, for which `isStaticOwner` is true. For example, + * class C { object O } + * OModuleClass.isStatic is true after flatten. Using phase travel to get before flatten, + * method `owner` returns the class C. + * + * Why not make a stable version of `isStatic`? Maybe some parts of the compiler depend on the + * current implementation. For example + * trait T { def foo = 1 } + * The method `foo` in the implementation class T$impl will be `isStatic`, because trait + * impl classes get the `lateMODULE` flag (T$impl.isStaticOwner is true). */ def isStatic = (this hasFlag STATIC) || owner.isStaticOwner @@ -1106,7 +1147,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => * - After lambdalift, all local method and class definitions (those not owned by a class * or package class) change their owner to the enclosing class. This is done through * a destructive "sym.owner = sym.owner.enclClass". The old owner is saved by - * saveOriginalOwner for the backend (needed to generate the EnclosingMethod attribute). + * saveOriginalOwner. * - After flatten, all classes are owned by a PackageClass. This is done through a * phase check (if after flatten) in the (overridden) method "def owner" in * ModuleSymbol / ClassSymbol. The `rawowner` field is not modified. @@ -1129,6 +1170,11 @@ trait Symbols extends api.Symbols { self: SymbolTable => final def safeOwner: Symbol = if (this eq NoSymbol) NoSymbol else owner final def assertOwner: Symbol = if (this eq NoSymbol) abort("no-symbol does not have an owner") else owner + /** + * The initial owner of this symbol. + */ + def originalOwner: Symbol = originalOwnerMap.getOrElse(this, rawowner) + // TODO - don't allow the owner to be changed without checking invariants, at least // when under some flag. Define per-phase invariants for owner/owned relationships, // e.g. after flatten all classes are owned by package classes, there are lots and @@ -1142,7 +1188,6 @@ trait Symbols extends api.Symbols { self: SymbolTable => } def ownerChain: List[Symbol] = this :: owner.ownerChain - def originalOwnerChain: List[Symbol] = this :: originalOwner.getOrElse(this, rawowner).originalOwnerChain // Non-classes skip self and return rest of owner chain; overridden in ClassSymbol. def enclClassChain: List[Symbol] = owner.enclClassChain diff --git a/src/reflect/scala/reflect/runtime/SymbolLoaders.scala b/src/reflect/scala/reflect/runtime/SymbolLoaders.scala index 7ba68b873341..50ea8d986877 100644 --- a/src/reflect/scala/reflect/runtime/SymbolLoaders.scala +++ b/src/reflect/scala/reflect/runtime/SymbolLoaders.scala @@ -65,10 +65,15 @@ private[reflect] trait SymbolLoaders { self: SymbolTable => class LazyPackageType extends LazyType with FlagAgnosticCompleter { override def complete(sym: Symbol) { assert(sym.isPackageClass) - sym setInfo new ClassInfoType(List(), new PackageScope(sym), sym) + // Time travel to a phase before refchecks avoids an initialization issue. `openPackageModule` + // creates a module symbol and invokes invokes `companionModule` while the `infos` field is + // still null. This calls `isModuleNotMethod`, which forces the `info` if run after refchecks. + slowButSafeEnteringPhaseNotLaterThan(picklerPhase) { + sym setInfo new ClassInfoType(List(), new PackageScope(sym), sym) // override def safeToString = pkgClass.toString - openPackageModule(sym) - markAllCompleted(sym) + openPackageModule(sym) + markAllCompleted(sym) + } } } From ee706b873a288deaba55df0b55768e86af0b0167 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 10 Jun 2014 11:37:26 +0200 Subject: [PATCH 374/826] Support writing classfile of version 52 --- src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala | 1 + src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala | 1 + .../scala/tools/nsc/settings/StandardScalaSettings.scala | 2 +- 3 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala index 9b7c9759607a..2343d378db7b 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala @@ -34,6 +34,7 @@ abstract class BCodeIdiomatic extends SubComponent { case "jvm-1.5" => asm.Opcodes.V1_5 case "jvm-1.6" => asm.Opcodes.V1_6 case "jvm-1.7" => asm.Opcodes.V1_7 + case "jvm-1.8" => asm.Opcodes.V1_8 } val majorVersion: Int = (classfileVersion & 0xFF) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala index ce7e7c49ffc6..d04b111d58bb 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala @@ -381,6 +381,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { case "jvm-1.5" => asm.Opcodes.V1_5 case "jvm-1.6" => asm.Opcodes.V1_6 case "jvm-1.7" => asm.Opcodes.V1_7 + case "jvm-1.8" => asm.Opcodes.V1_8 } private val majorVersion: Int = (classfileVersion & 0xFF) diff --git a/src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala index 37dfafb01c06..d42c0dd730d8 100644 --- a/src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala @@ -39,7 +39,7 @@ trait StandardScalaSettings { val optimise: BooleanSetting // depends on post hook which mutates other settings val print = BooleanSetting ("-print", "Print program with Scala-specific features removed.") val target = ChoiceSetting ("-target", "target", "Target platform for object files. All JVM 1.5 targets are deprecated.", - List("jvm-1.5", "jvm-1.6", "jvm-1.7"), "jvm-1.6") + List("jvm-1.5", "jvm-1.6", "jvm-1.7", "jvm-1.8"), "jvm-1.6") val unchecked = BooleanSetting ("-unchecked", "Enable additional warnings where generated code depends on assumptions.") val uniqid = BooleanSetting ("-uniqid", "Uniquely tag all identifiers in debugging output.") val usejavacp = BooleanSetting ("-usejavacp", "Utilize the java.class.path in classpath resolution.") From a8c88b194eefd5d4d55361b934faa0ebd954ef08 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 10 Jun 2014 11:38:24 +0200 Subject: [PATCH 375/826] Documentation for isModuleClass --- src/reflect/scala/reflect/api/Symbols.scala | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/reflect/scala/reflect/api/Symbols.scala b/src/reflect/scala/reflect/api/Symbols.scala index dddd3c0e61d7..42cf600c85bf 100644 --- a/src/reflect/scala/reflect/api/Symbols.scala +++ b/src/reflect/scala/reflect/api/Symbols.scala @@ -260,6 +260,9 @@ trait Symbols { self: Universe => * with an object definition (module class in scala compiler parlance). * If yes, `isType` is also guaranteed to be true. * + * Note to compiler developers: During the "mixin" phase, trait implementation class symbols + * receive the `lateMODULE` flag, hence `isImplClass && isModuleClass` becomes true. + * * @group Tests */ def isModuleClass: Boolean = false From 80a9e908fd7b591a6fe452d908407d537675a999 Mon Sep 17 00:00:00 2001 From: Max Bileschi Date: Tue, 8 Jul 2014 09:49:07 -0400 Subject: [PATCH 376/826] som-snytt's update to wording --- src/library/scala/PartialFunction.scala | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/library/scala/PartialFunction.scala b/src/library/scala/PartialFunction.scala index 045ea319d922..98dd35d306e6 100644 --- a/src/library/scala/PartialFunction.scala +++ b/src/library/scala/PartialFunction.scala @@ -22,9 +22,9 @@ package scala * }}} * * It is the responsibility of the caller to call `isDefinedAt` before - * before calling `apply`, because if `isDefinedAt` is false, an exception - * may or may not be thrown. In the case that an exception is not thrown, - * an insane value may be returned. + * calling `apply`, because if `isDefinedAt` is false, it is not guaranteed + * `apply` will throw an exception to indicate an error condition. If an + * exception is not thrown, evaluation may result in an arbitrary value. * * The main distinction between `PartialFunction` and [[scala.Function1]] is * that the user of a `PartialFunction` may choose to do something different From 2103dbc5230ddf2a369389f179f4ef70eae344f2 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Thu, 22 May 2014 09:02:18 -0700 Subject: [PATCH 377/826] SI-8610 -Xlint is multichoice option Make -Xlint a "multichoice" option for purposes of option parsing. This allows turning on "lint with these warnings" instead of only "turn off these warnings but enable other lint warnings". ``` $ scalac -Xlint:warn-adapted-args linty.scala # lint plus a warning $ scalac -Xlint warn-adapted-args linty.scala # same $ scalac -Xlint linty.scala # same as now $ scalac -Xlint -- linty.scala # ok, not necessary $ scalac -Xlint _ -- linty.scala # another funky underscore ``` This would also enable Xlint options that are not standalone options, although that is not implemented in this commit. For example, `-Xlint:no-missing-interpolator` could be used to disable that warning. (There is no `-Xoption:flavor=off` syntax.) (`no-` switches would not be enabled by `_`.) --- .../tools/nsc/settings/AbsScalaSettings.scala | 2 +- .../tools/nsc/settings/MutableSettings.scala | 48 ++++++++++++------- .../scala/tools/nsc/settings/Warnings.scala | 22 ++++++++- test/files/neg/t8610-arg.check | 9 ++++ test/files/neg/t8610-arg.flags | 1 + test/files/neg/t8610-arg.scala | 7 +++ test/files/neg/t8610.check | 15 ++++++ test/files/neg/t8610.flags | 1 + test/files/neg/t8610.scala | 7 +++ test/files/run/t8610.check | 10 ++++ test/files/run/t8610.flags | 1 + test/files/run/t8610.scala | 13 +++++ 12 files changed, 116 insertions(+), 20 deletions(-) create mode 100644 test/files/neg/t8610-arg.check create mode 100644 test/files/neg/t8610-arg.flags create mode 100644 test/files/neg/t8610-arg.scala create mode 100644 test/files/neg/t8610.check create mode 100644 test/files/neg/t8610.flags create mode 100644 test/files/neg/t8610.scala create mode 100644 test/files/run/t8610.check create mode 100644 test/files/run/t8610.flags create mode 100644 test/files/run/t8610.scala diff --git a/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala index 38a75258627d..ef9695a5949f 100644 --- a/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala @@ -29,7 +29,7 @@ trait AbsScalaSettings { def ChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: String): ChoiceSetting def IntSetting(name: String, descr: String, default: Int, range: Option[(Int, Int)], parser: String => Option[Int]): IntSetting def MultiStringSetting(name: String, helpArg: String, descr: String): MultiStringSetting - def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String]): MultiChoiceSetting + def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: () => Unit): MultiChoiceSetting def OutputSetting(outputDirs: OutputDirs, default: String): OutputSetting def PathSetting(name: String, descr: String, default: String): PathSetting def PhasesSetting(name: String, descr: String, default: String): PhasesSetting diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala index 54e444decff0..5b5c80c5140a 100644 --- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala @@ -211,10 +211,10 @@ class MutableSettings(val errorFn: String => Unit) add(new ChoiceSetting(name, helpArg, descr, choices, default)) def IntSetting(name: String, descr: String, default: Int, range: Option[(Int, Int)], parser: String => Option[Int]) = add(new IntSetting(name, descr, default, range, parser)) def MultiStringSetting(name: String, arg: String, descr: String) = add(new MultiStringSetting(name, arg, descr)) - def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String]): MultiChoiceSetting = { + def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: () => Unit = () => ()): MultiChoiceSetting = { val fullChoix = choices.mkString(": ", ",", ".") val fullDescr = s"$descr$fullChoix" - add(new MultiChoiceSetting(name, helpArg, fullDescr, choices)) + add(new MultiChoiceSetting(name, helpArg, fullDescr, choices, default)) } def OutputSetting(outputDirs: OutputDirs, default: String) = add(new OutputSetting(outputDirs, default)) def PhasesSetting(name: String, descr: String, default: String = "") = add(new PhasesSetting(name, descr, default)) @@ -553,12 +553,18 @@ class MutableSettings(val errorFn: String => Unit) } } + /** A setting that receives any combination of enumerated values, + * including "_" to mean all values. + * In non-colonated mode, stops consuming args at the first + * non-value, instead of at the next option, as for a multi-string. + */ class MultiChoiceSetting private[nsc]( name: String, arg: String, descr: String, - override val choices: List[String]) - extends MultiStringSetting(name, arg, descr) + override val choices: List[String], + override val default: () => Unit + ) extends MultiStringSetting(name, arg, descr) /** A setting that accumulates all strings supplied to it, * until it encounters one starting with a '-'. @@ -570,24 +576,34 @@ class MutableSettings(val errorFn: String => Unit) extends Setting(name, descr) with Clearable { type T = List[String] protected var v: T = Nil + val default: () => Unit = () => () // no natural default def appendToValue(str: String) { value ++= List(str) } def badChoice(s: String, n: String) = errorFn(s"'$s' is not a valid choice for '$name'") - def tryToSet(args: List[String]) = { - val (strings, rest) = args span (x => !x.startsWith("-")) - strings foreach { - case "_" if choices.nonEmpty => choices foreach appendToValue + private def tts(args: List[String], verify: Boolean) = { + def tryArg(arg: String) = arg match { + case "_" if choices.nonEmpty => choices foreach appendToValue case s if choices.isEmpty || (choices contains s) => appendToValue(s) - case s => badChoice(s, name) + case s => badChoice(s, name) } + def loop(args: List[String]): List[String] = args match { + case Nil => Nil + case arg :: _ + if (arg startsWith "-") || (!verify && choices.nonEmpty && !(choices contains arg)) + => args + case arg :: rest => tryArg(arg) ; loop(rest) + } + val rest = loop(args) + if (rest.size == args.size) default() // if no arg consumed, trigger default action Some(rest) } - override def tryToSetColon(args: List[String]) = tryToSet(args) + def tryToSet(args: List[String]) = tts(args, verify = false) + override def tryToSetColon(args: List[String]) = tts(args, verify = true) override def tryToSetFromPropertyValue(s: String) = tryToSet(s.trim.split(',').toList) // used from ide - def clear(): Unit = (v = Nil) - def unparse: List[String] = value map (name + ":" + _) - def contains(s: String) = value contains s + def clear(): Unit = (v = Nil) + def unparse: List[String] = value map (name + ":" + _) + def contains(s: String) = value contains s withHelpSyntax(name + ":<" + arg + ">") } @@ -606,10 +622,8 @@ class MutableSettings(val errorFn: String => Unit) protected var v: T = default def indexOfChoice: Int = choices indexOf value - private def usageErrorMessage = { - "Usage: %s:<%s>\n where <%s> choices are %s (default: %s)\n".format( - name, helpArg, helpArg, choices mkString ", ", default) - } + private def usageErrorMessage = f"Usage: $name:<$helpArg>%n where <$helpArg> choices are ${choices mkString ", "} (default: $default)%n" + def tryToSet(args: List[String]) = errorAndValue(usageErrorMessage, None) override def tryToSetColon(args: List[String]) = args match { diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala index 1509ad13b852..ae2696accf6f 100644 --- a/src/compiler/scala/tools/nsc/settings/Warnings.scala +++ b/src/compiler/scala/tools/nsc/settings/Warnings.scala @@ -50,8 +50,26 @@ trait Warnings { val warnUnused = BooleanSetting ("-Ywarn-unused", "Warn when local and private vals, vars, defs, and types are are unused") val warnUnusedImport = BooleanSetting ("-Ywarn-unused-import", "Warn when imports are unused") - // Warning groups. - val lint = BooleanSetting("-Xlint", "Enable recommended additional warnings.") enablingIfNotSetByUser lintWarnings + // Warning groups. + val lint = { + // Boolean setting for testing if lint is on; not "added" to option processing + val xlint = new BooleanSetting("-Xlint", "Enable recommended additional warnings.") + val lintables = (lintWarnings map (_.name drop 2)).sorted + def propagate(ss: List[String]): Unit = ss match { + case w :: rest => lintWarnings find (_.name == s"-Y$w") foreach (_.value = true) ; propagate(rest) + case Nil => () + } + def enableAll(): Unit = { // enable lint and the group + xlint.value = true + for (s <- lintWarnings if !s.isSetByUser) s.value = true + } + // The command option + MultiChoiceSetting("-Xlint", "warning", "Enable recommended additional warnings", lintables, enableAll) withPostSetHook { x => + propagate(x.value) // enabling the selections (on each append to value) + xlint.value = true // only enables lint, not the group + } + xlint + } // Backward compatibility. @deprecated("Use fatalWarnings", "2.11.0") def Xwarnfatal = fatalWarnings // used by sbt diff --git a/test/files/neg/t8610-arg.check b/test/files/neg/t8610-arg.check new file mode 100644 index 000000000000..f2879b0d45fe --- /dev/null +++ b/test/files/neg/t8610-arg.check @@ -0,0 +1,9 @@ +t8610-arg.scala:3: warning: `$name` looks like an interpolated identifier! Did you forget the interpolator? + def x = "Hi, $name" // missing interp + ^ +t8610-arg.scala:6: warning: side-effecting nullary methods are discouraged: suggest defining as `def u()` instead + def u: Unit = () // unitarian universalist + ^ +error: No warnings can be incurred under -Xfatal-warnings. +two warnings found +one error found diff --git a/test/files/neg/t8610-arg.flags b/test/files/neg/t8610-arg.flags new file mode 100644 index 000000000000..f8867a7b4e69 --- /dev/null +++ b/test/files/neg/t8610-arg.flags @@ -0,0 +1 @@ +-Xfatal-warnings -Xlint warn-nullary-unit diff --git a/test/files/neg/t8610-arg.scala b/test/files/neg/t8610-arg.scala new file mode 100644 index 000000000000..494a3354da21 --- /dev/null +++ b/test/files/neg/t8610-arg.scala @@ -0,0 +1,7 @@ + +case class X(name: String) { + def x = "Hi, $name" // missing interp + def f(p: (Int, Int)): Int = p._1 * p._2 + def g = f(3, 4) // adapted + def u: Unit = () // unitarian universalist +} diff --git a/test/files/neg/t8610.check b/test/files/neg/t8610.check new file mode 100644 index 000000000000..7a18e55127c1 --- /dev/null +++ b/test/files/neg/t8610.check @@ -0,0 +1,15 @@ +t8610.scala:3: warning: `$name` looks like an interpolated identifier! Did you forget the interpolator? + def x = "Hi, $name" // missing interp + ^ +t8610.scala:5: warning: Adapting argument list by creating a 2-tuple: this may not be what you want. + signature: X.f(p: (Int, Int)): Int + given arguments: 3, 4 + after adaptation: X.f((3, 4): (Int, Int)) + def g = f(3, 4) // adapted + ^ +t8610.scala:6: warning: side-effecting nullary methods are discouraged: suggest defining as `def u()` instead + def u: Unit = () // unitarian universalist + ^ +error: No warnings can be incurred under -Xfatal-warnings. +three warnings found +one error found diff --git a/test/files/neg/t8610.flags b/test/files/neg/t8610.flags new file mode 100644 index 000000000000..954eaba3523b --- /dev/null +++ b/test/files/neg/t8610.flags @@ -0,0 +1 @@ +-Xfatal-warnings -Xlint diff --git a/test/files/neg/t8610.scala b/test/files/neg/t8610.scala new file mode 100644 index 000000000000..494a3354da21 --- /dev/null +++ b/test/files/neg/t8610.scala @@ -0,0 +1,7 @@ + +case class X(name: String) { + def x = "Hi, $name" // missing interp + def f(p: (Int, Int)): Int = p._1 * p._2 + def g = f(3, 4) // adapted + def u: Unit = () // unitarian universalist +} diff --git a/test/files/run/t8610.check b/test/files/run/t8610.check new file mode 100644 index 000000000000..077382fb1cf5 --- /dev/null +++ b/test/files/run/t8610.check @@ -0,0 +1,10 @@ +t8610.scala:4: warning: `$name` looks like an interpolated identifier! Did you forget the interpolator? + def x = "Hi, $name" // missing interp + ^ +t8610.scala:6: warning: Adapting argument list by creating a 2-tuple: this may not be what you want. + signature: X.f(p: (Int, Int)): Int + given arguments: 3, 4 + after adaptation: X.f((3, 4): (Int, Int)) + def g = f(3, 4) // adapted + ^ +Hi, $name diff --git a/test/files/run/t8610.flags b/test/files/run/t8610.flags new file mode 100644 index 000000000000..edcb5f4d0c54 --- /dev/null +++ b/test/files/run/t8610.flags @@ -0,0 +1 @@ +-Xlint:warn-adapted-args diff --git a/test/files/run/t8610.scala b/test/files/run/t8610.scala new file mode 100644 index 000000000000..dd9e8e861e71 --- /dev/null +++ b/test/files/run/t8610.scala @@ -0,0 +1,13 @@ + +// flags don't warn on u +case class X(name: String) { + def x = "Hi, $name" // missing interp + def f(p: (Int, Int)): Int = p._1 * p._2 + def g = f(3, 4) // adapted + def u: Unit = () // unitarian universalist +} + +object Test extends App { + // poignant demonstration + Console println X("Bob").x +} From 91670d91824493e8bbbd88e9861e04e710311cbb Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Sat, 24 May 2014 01:31:20 -0700 Subject: [PATCH 378/826] SI-8616 Error on -deprecation:true,false This is an error, not a crash. Alternatively, one could define the multivalued colon case as equivalent to specifying the option multiple times. That would be very regular. But sometimes it's nicer just to error out. --- src/compiler/scala/tools/nsc/settings/MutableSettings.scala | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala index 5b5c80c5140a..b399c0e02439 100644 --- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala @@ -444,7 +444,7 @@ class MutableSettings(val errorFn: String => Unit) value = s.equalsIgnoreCase("true") } override def tryToSetColon(args: List[String]) = args match { - case Nil => tryToSet(Nil) + case Nil => tryToSet(Nil) case List(x) => if (x.equalsIgnoreCase("true")) { value = true @@ -452,7 +452,8 @@ class MutableSettings(val errorFn: String => Unit) } else if (x.equalsIgnoreCase("false")) { value = false Some(Nil) - } else errorAndValue("'" + x + "' is not a valid choice for '" + name + "'", None) + } else errorAndValue(s"'$x' is not a valid choice for '$name'", None) + case _ => errorAndValue(s"'$name' accepts only one boolean value", None) } } From 44855dcd3c2e19d5dbaf01b2165ea8dc9fb287d3 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Sat, 24 May 2014 06:08:17 -0700 Subject: [PATCH 379/826] SI-8525 Add -Xlint:-warn-missing-interpolator Turn off lint warnings with negating prefix, and add a lint-only warning for the infamously nagging "Did you forget the interpolator?" That message is made more dignified. Without `-Xlint:false`, there is no mechanism to turn off anonymous linters once `-Xlint` is selected. --- .../tools/nsc/settings/MutableSettings.scala | 61 +++++++++++-------- .../scala/tools/nsc/settings/Warnings.scala | 24 +++++--- .../scala/tools/nsc/typechecker/Typers.scala | 8 +-- test/files/neg/forgot-interpolator.check | 16 ++--- test/files/neg/t7848-interp-warn.check | 6 +- test/files/neg/t8525.check | 6 ++ test/files/neg/t8525.flags | 1 + test/files/neg/t8525.scala | 10 +++ test/files/neg/t8610-arg.check | 9 ++- test/files/neg/t8610-arg.scala | 5 +- test/files/neg/t8610.check | 11 ++-- test/files/neg/t8610.scala | 5 +- test/files/run/t8610.check | 2 +- .../tools/nsc/settings/SettingsTest.scala | 18 +++++- 14 files changed, 123 insertions(+), 59 deletions(-) create mode 100644 test/files/neg/t8525.check create mode 100644 test/files/neg/t8525.flags create mode 100644 test/files/neg/t8525.scala diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala index b399c0e02439..dc49e8b822a2 100644 --- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala @@ -211,11 +211,8 @@ class MutableSettings(val errorFn: String => Unit) add(new ChoiceSetting(name, helpArg, descr, choices, default)) def IntSetting(name: String, descr: String, default: Int, range: Option[(Int, Int)], parser: String => Option[Int]) = add(new IntSetting(name, descr, default, range, parser)) def MultiStringSetting(name: String, arg: String, descr: String) = add(new MultiStringSetting(name, arg, descr)) - def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: () => Unit = () => ()): MultiChoiceSetting = { - val fullChoix = choices.mkString(": ", ",", ".") - val fullDescr = s"$descr$fullChoix" - add(new MultiChoiceSetting(name, helpArg, fullDescr, choices, default)) - } + def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: () => Unit = () => ()) = + add(new MultiChoiceSetting(name, helpArg, descr, choices, default)) def OutputSetting(outputDirs: OutputDirs, default: String) = add(new OutputSetting(outputDirs, default)) def PhasesSetting(name: String, descr: String, default: String = "") = add(new PhasesSetting(name, descr, default)) def StringSetting(name: String, arg: String, descr: String, default: String) = add(new StringSetting(name, arg, descr, default)) @@ -564,8 +561,33 @@ class MutableSettings(val errorFn: String => Unit) arg: String, descr: String, override val choices: List[String], - override val default: () => Unit - ) extends MultiStringSetting(name, arg, descr) + val default: () => Unit + ) extends MultiStringSetting(name, arg, s"$descr${ choices.mkString(": ", ",", ".") }") { + + def badChoice(s: String, n: String) = errorFn(s"'$s' is not a valid choice for '$name'") + def choosing = choices.nonEmpty + def isChoice(s: String) = (s == "_") || (choices contains (s stripPrefix "-")) + def wildcards = choices // filter (!_.isSetByUser) + + override protected def tts(args: List[String], halting: Boolean) = { + val total = collection.mutable.ListBuffer.empty[String] ++ value + def tryArg(arg: String) = arg match { + case "_" if choosing => wildcards foreach (total += _) + case s if !choosing || isChoice(s) => total += s + case s => badChoice(s, name) + } + def stoppingAt(arg: String) = (arg startsWith "-") || (choosing && !isChoice(arg)) + def loop(args: List[String]): List[String] = args match { + case arg :: _ if halting && stoppingAt(arg) => args + case arg :: rest => tryArg(arg) ; loop(rest) + case Nil => Nil + } + val rest = loop(args) + if (rest.size == args.size) default() // if no arg consumed, trigger default action + else value = total.toList // update once + Some(rest) + } + } /** A setting that accumulates all strings supplied to it, * until it encounters one starting with a '-'. @@ -577,29 +599,18 @@ class MutableSettings(val errorFn: String => Unit) extends Setting(name, descr) with Clearable { type T = List[String] protected var v: T = Nil - val default: () => Unit = () => () // no natural default - def appendToValue(str: String) { value ++= List(str) } - def badChoice(s: String, n: String) = errorFn(s"'$s' is not a valid choice for '$name'") + def appendToValue(str: String) = value ++= List(str) - private def tts(args: List[String], verify: Boolean) = { - def tryArg(arg: String) = arg match { - case "_" if choices.nonEmpty => choices foreach appendToValue - case s if choices.isEmpty || (choices contains s) => appendToValue(s) - case s => badChoice(s, name) - } + // try to set. halting means halt at first non-arg + protected def tts(args: List[String], halting: Boolean) = { def loop(args: List[String]): List[String] = args match { + case arg :: rest => if (halting && (arg startsWith "-")) args else { appendToValue(arg) ; loop(rest) } case Nil => Nil - case arg :: _ - if (arg startsWith "-") || (!verify && choices.nonEmpty && !(choices contains arg)) - => args - case arg :: rest => tryArg(arg) ; loop(rest) } - val rest = loop(args) - if (rest.size == args.size) default() // if no arg consumed, trigger default action - Some(rest) + Some(loop(args)) } - def tryToSet(args: List[String]) = tts(args, verify = false) - override def tryToSetColon(args: List[String]) = tts(args, verify = true) + def tryToSet(args: List[String]) = tts(args, halting = true) + override def tryToSetColon(args: List[String]) = tts(args, halting = false) override def tryToSetFromPropertyValue(s: String) = tryToSet(s.trim.split(',').toList) // used from ide def clear(): Unit = (v = Nil) diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala index ae2696accf6f..f1ed45a2a0b6 100644 --- a/src/compiler/scala/tools/nsc/settings/Warnings.scala +++ b/src/compiler/scala/tools/nsc/settings/Warnings.scala @@ -31,9 +31,10 @@ trait Warnings { warnNullaryOverride, warnNullaryUnit, warnAdaptedArgs, - warnInferAny + warnInferAny, // warnUnused SI-7712, SI-7707 warnUnused not quite ready for prime-time // warnUnusedImport currently considered too noisy for general use + warnMissingInterpolator ) private lazy val warnSelectNullable = BooleanSetting("-Xcheck-null", "This option is obsolete and does nothing.") @@ -50,23 +51,32 @@ trait Warnings { val warnUnused = BooleanSetting ("-Ywarn-unused", "Warn when local and private vals, vars, defs, and types are are unused") val warnUnusedImport = BooleanSetting ("-Ywarn-unused-import", "Warn when imports are unused") + // Lint warnings that are not -Y + val warnMissingInterpolator = new BooleanSetting("warn-missing-interpolator", "Warn when a string literal appears to be missing an interpolator id.") + // Warning groups. val lint = { // Boolean setting for testing if lint is on; not "added" to option processing val xlint = new BooleanSetting("-Xlint", "Enable recommended additional warnings.") - val lintables = (lintWarnings map (_.name drop 2)).sorted + def lintables = (lintWarnings map (_.name stripPrefix "-Y")).sorted + def isAnon(b: BooleanSetting) = !(b.name startsWith "-") + def setPolitely(b: BooleanSetting, v: Boolean) = if (!b.isSetByUser) b.value = v + def set(w: String, v: Boolean) = lintWarnings find (_.name.stripPrefix("-Y") == w) foreach (b => setPolitely(b, v)) + val Neg = "-" def propagate(ss: List[String]): Unit = ss match { - case w :: rest => lintWarnings find (_.name == s"-Y$w") foreach (_.value = true) ; propagate(rest) - case Nil => () + case w :: rest => if (w startsWith Neg) set(w stripPrefix Neg, false) else set(w, true) ; propagate(rest) + case Nil => () } - def enableAll(): Unit = { // enable lint and the group + // enable lint and the group, honoring previous -Y settings + def enableAll(): Unit = { xlint.value = true - for (s <- lintWarnings if !s.isSetByUser) s.value = true + for (s <- lintWarnings) setPolitely(s, true) } // The command option - MultiChoiceSetting("-Xlint", "warning", "Enable recommended additional warnings", lintables, enableAll) withPostSetHook { x => + MultiChoiceSetting("-Xlint", "warning", "Enable recommended additional warnings", choices = lintables, default = enableAll) withPostSetHook { x => propagate(x.value) // enabling the selections (on each append to value) xlint.value = true // only enables lint, not the group + for (b <- lintWarnings if isAnon(b) && !b.isSetByUser) b.value = true // init anonymous settings (but not if disabled) } xlint } diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 2c31ef2e8eab..efc121d47981 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -5099,7 +5099,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper def isPlausible(m: Symbol) = m.alternatives exists (m => requiresNoArgs(m.info)) def maybeWarn(s: String): Unit = { - def warn(message: String) = context.warning(lit.pos, s"$message Did you forget the interpolator?") + def warn(message: String) = context.warning(lit.pos, s"possible missing interpolator: $message") def suspiciousSym(name: TermName) = context.lookupSymbol(name, _ => true).symbol def suspiciousExpr = InterpolatorCodeRegex findFirstIn s def suspiciousIdents = InterpolatorIdentRegex findAllIn s map (s => suspiciousSym(s drop 1)) @@ -5107,9 +5107,9 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper // heuristics - no warning on e.g. a string with only "$asInstanceOf" if (s contains ' ') ( if (suspiciousExpr.nonEmpty) - warn("That looks like an interpolated expression!") // "${...}" + warn("detected an interpolated expression") // "${...}" else - suspiciousIdents find isPlausible foreach (sym => warn(s"`$$${sym.name}` looks like an interpolated identifier!")) // "$id" + suspiciousIdents find isPlausible foreach (sym => warn(s"detected interpolated identifier `$$${sym.name}`")) // "$id" ) } lit match { @@ -5119,7 +5119,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper } def typedLiteral(tree: Literal) = { - if (settings.lint) warnMissingInterpolator(tree) + if (settings.warnMissingInterpolator) warnMissingInterpolator(tree) tree setType (if (tree.value.tag == UnitTag) UnitTpe else ConstantType(tree.value)) } diff --git a/test/files/neg/forgot-interpolator.check b/test/files/neg/forgot-interpolator.check index 8988458982ee..8e75350518ed 100644 --- a/test/files/neg/forgot-interpolator.check +++ b/test/files/neg/forgot-interpolator.check @@ -1,25 +1,25 @@ -forgot-interpolator.scala:4: warning: `$bippy` looks like an interpolated identifier! Did you forget the interpolator? +forgot-interpolator.scala:4: warning: possible missing interpolator: detected interpolated identifier `$bippy` def f = "Put the $bippy in the $bippy!" // warn 1 ^ -forgot-interpolator.scala:14: warning: That looks like an interpolated expression! Did you forget the interpolator? +forgot-interpolator.scala:14: warning: possible missing interpolator: detected an interpolated expression def f = """Put the ${println("bippy")} in the bippy!""" // warn 2 ^ -forgot-interpolator.scala:30: warning: `$beppo` looks like an interpolated identifier! Did you forget the interpolator? +forgot-interpolator.scala:30: warning: possible missing interpolator: detected interpolated identifier `$beppo` def f = "$beppo was a marx bros who saw dollars." // warn 3 ^ -forgot-interpolator.scala:34: warning: `$aleppo` looks like an interpolated identifier! Did you forget the interpolator? +forgot-interpolator.scala:34: warning: possible missing interpolator: detected interpolated identifier `$aleppo` def f = "$aleppo is a pepper and a city." // warn 4 ^ -forgot-interpolator.scala:47: warning: `$hippo` looks like an interpolated identifier! Did you forget the interpolator? +forgot-interpolator.scala:47: warning: possible missing interpolator: detected interpolated identifier `$hippo` def h = "$hippo takes an implicit" // warn 6 ^ -forgot-interpolator.scala:88: warning: `$groucho` looks like an interpolated identifier! Did you forget the interpolator? +forgot-interpolator.scala:88: warning: possible missing interpolator: detected interpolated identifier `$groucho` def f2 = "I salute $groucho" // warn 7 ^ -forgot-interpolator.scala:89: warning: `$dingo` looks like an interpolated identifier! Did you forget the interpolator? +forgot-interpolator.scala:89: warning: possible missing interpolator: detected interpolated identifier `$dingo` def f3 = "I even salute $dingo" // warn 8 ^ -forgot-interpolator.scala:90: warning: `$calico` looks like an interpolated identifier! Did you forget the interpolator? +forgot-interpolator.scala:90: warning: possible missing interpolator: detected interpolated identifier `$calico` def f4 = "I also salute $calico" // warn 9 ^ error: No warnings can be incurred under -Xfatal-warnings. diff --git a/test/files/neg/t7848-interp-warn.check b/test/files/neg/t7848-interp-warn.check index b7df6d8ce252..4cf9d55ffd24 100644 --- a/test/files/neg/t7848-interp-warn.check +++ b/test/files/neg/t7848-interp-warn.check @@ -1,10 +1,10 @@ -t7848-interp-warn.scala:8: warning: `$foo` looks like an interpolated identifier! Did you forget the interpolator? +t7848-interp-warn.scala:8: warning: possible missing interpolator: detected interpolated identifier `$foo` "An important $foo message!" ^ -t7848-interp-warn.scala:12: warning: That looks like an interpolated expression! Did you forget the interpolator? +t7848-interp-warn.scala:12: warning: possible missing interpolator: detected an interpolated expression "A doubly important ${foo * 2} message!" ^ -t7848-interp-warn.scala:16: warning: `$bar` looks like an interpolated identifier! Did you forget the interpolator? +t7848-interp-warn.scala:16: warning: possible missing interpolator: detected interpolated identifier `$bar` def j = s"Try using '${ "something like $bar" }' instead." // warn ^ error: No warnings can be incurred under -Xfatal-warnings. diff --git a/test/files/neg/t8525.check b/test/files/neg/t8525.check new file mode 100644 index 000000000000..554ab23253e4 --- /dev/null +++ b/test/files/neg/t8525.check @@ -0,0 +1,6 @@ +t8525.scala:9: warning: private[this] value name in class X shadows mutable name inherited from class Named. Changes to name will not be visible within class X - you may want to give them distinct names. + override def toString = name // shadowing mutable var name + ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found +one error found diff --git a/test/files/neg/t8525.flags b/test/files/neg/t8525.flags new file mode 100644 index 000000000000..f19af1f71739 --- /dev/null +++ b/test/files/neg/t8525.flags @@ -0,0 +1 @@ +-Xfatal-warnings -Xlint:-warn-missing-interpolator diff --git a/test/files/neg/t8525.scala b/test/files/neg/t8525.scala new file mode 100644 index 000000000000..7bed04904fb3 --- /dev/null +++ b/test/files/neg/t8525.scala @@ -0,0 +1,10 @@ + +class Named(var name: String) + +class X(name: String) extends Named(name) { + def x = "Hi, $name" // missing interp + def f(p: (Int, Int)): Int = p._1 * p._2 + def g = f(3, 4) // adapted + def u: Unit = () // unitarian universalist + override def toString = name // shadowing mutable var name +} diff --git a/test/files/neg/t8610-arg.check b/test/files/neg/t8610-arg.check index f2879b0d45fe..4f194ce84a00 100644 --- a/test/files/neg/t8610-arg.check +++ b/test/files/neg/t8610-arg.check @@ -1,9 +1,12 @@ -t8610-arg.scala:3: warning: `$name` looks like an interpolated identifier! Did you forget the interpolator? +t8610-arg.scala:5: warning: possible missing interpolator: detected interpolated identifier `$name` def x = "Hi, $name" // missing interp ^ -t8610-arg.scala:6: warning: side-effecting nullary methods are discouraged: suggest defining as `def u()` instead +t8610-arg.scala:9: warning: private[this] value name in class X shadows mutable name inherited from class Named. Changes to name will not be visible within class X - you may want to give them distinct names. + override def toString = name // shadowing mutable var name + ^ +t8610-arg.scala:8: warning: side-effecting nullary methods are discouraged: suggest defining as `def u()` instead def u: Unit = () // unitarian universalist ^ error: No warnings can be incurred under -Xfatal-warnings. -two warnings found +three warnings found one error found diff --git a/test/files/neg/t8610-arg.scala b/test/files/neg/t8610-arg.scala index 494a3354da21..7bed04904fb3 100644 --- a/test/files/neg/t8610-arg.scala +++ b/test/files/neg/t8610-arg.scala @@ -1,7 +1,10 @@ -case class X(name: String) { +class Named(var name: String) + +class X(name: String) extends Named(name) { def x = "Hi, $name" // missing interp def f(p: (Int, Int)): Int = p._1 * p._2 def g = f(3, 4) // adapted def u: Unit = () // unitarian universalist + override def toString = name // shadowing mutable var name } diff --git a/test/files/neg/t8610.check b/test/files/neg/t8610.check index 7a18e55127c1..334a94754990 100644 --- a/test/files/neg/t8610.check +++ b/test/files/neg/t8610.check @@ -1,15 +1,18 @@ -t8610.scala:3: warning: `$name` looks like an interpolated identifier! Did you forget the interpolator? +t8610.scala:5: warning: possible missing interpolator: detected interpolated identifier `$name` def x = "Hi, $name" // missing interp ^ -t8610.scala:5: warning: Adapting argument list by creating a 2-tuple: this may not be what you want. +t8610.scala:7: warning: Adapting argument list by creating a 2-tuple: this may not be what you want. signature: X.f(p: (Int, Int)): Int given arguments: 3, 4 after adaptation: X.f((3, 4): (Int, Int)) def g = f(3, 4) // adapted ^ -t8610.scala:6: warning: side-effecting nullary methods are discouraged: suggest defining as `def u()` instead +t8610.scala:9: warning: private[this] value name in class X shadows mutable name inherited from class Named. Changes to name will not be visible within class X - you may want to give them distinct names. + override def toString = name // shadowing mutable var name + ^ +t8610.scala:8: warning: side-effecting nullary methods are discouraged: suggest defining as `def u()` instead def u: Unit = () // unitarian universalist ^ error: No warnings can be incurred under -Xfatal-warnings. -three warnings found +four warnings found one error found diff --git a/test/files/neg/t8610.scala b/test/files/neg/t8610.scala index 494a3354da21..7bed04904fb3 100644 --- a/test/files/neg/t8610.scala +++ b/test/files/neg/t8610.scala @@ -1,7 +1,10 @@ -case class X(name: String) { +class Named(var name: String) + +class X(name: String) extends Named(name) { def x = "Hi, $name" // missing interp def f(p: (Int, Int)): Int = p._1 * p._2 def g = f(3, 4) // adapted def u: Unit = () // unitarian universalist + override def toString = name // shadowing mutable var name } diff --git a/test/files/run/t8610.check b/test/files/run/t8610.check index 077382fb1cf5..0e0dfc2cd343 100644 --- a/test/files/run/t8610.check +++ b/test/files/run/t8610.check @@ -1,4 +1,4 @@ -t8610.scala:4: warning: `$name` looks like an interpolated identifier! Did you forget the interpolator? +t8610.scala:4: warning: possible missing interpolator: detected interpolated identifier `$name` def x = "Hi, $name" // missing interp ^ t8610.scala:6: warning: Adapting argument list by creating a 2-tuple: this may not be what you want. diff --git a/test/junit/scala/tools/nsc/settings/SettingsTest.scala b/test/junit/scala/tools/nsc/settings/SettingsTest.scala index e4b5ecc7c32e..29591727a31e 100644 --- a/test/junit/scala/tools/nsc/settings/SettingsTest.scala +++ b/test/junit/scala/tools/nsc/settings/SettingsTest.scala @@ -26,7 +26,7 @@ class SettingsTest { assertThrows[IllegalArgumentException](check("-Ytest-setting:rubbish")) } - @Test def userSettingsHavePredecenceOverOptimize() { + @Test def userSettingsHavePrecedenceOverOptimize() { def check(args: String*): MutableSettings#BooleanSetting = { val s = new MutableSettings(msg => throw new IllegalArgumentException(msg)) val (ok, residual) = s.processArguments(args.toList, processAll = true) @@ -38,7 +38,7 @@ class SettingsTest { assertFalse(check("-Yinline:false", "-optimise").value) } - @Test def userSettingsHavePredecenceOverLint() { + @Test def userSettingsHavePrecedenceOverLint() { def check(args: String*): MutableSettings#BooleanSetting = { val s = new MutableSettings(msg => throw new IllegalArgumentException(msg)) val (ok, residual) = s.processArguments(args.toList, processAll = true) @@ -49,4 +49,18 @@ class SettingsTest { assertFalse(check("-Xlint", "-Ywarn-adapted-args:false").value) assertFalse(check("-Ywarn-adapted-args:false", "-Xlint").value) } + + def check(args: String*)(b: MutableSettings => MutableSettings#BooleanSetting): MutableSettings#BooleanSetting = { + val s = new MutableSettings(msg => throw new IllegalArgumentException(msg)) + val (ok, residual) = s.processArguments(args.toList, processAll = true) + assert(residual.isEmpty) + b(s) + } + @Test def anonymousLintersCanBeNamed() { + assertTrue(check("-Xlint")(_.warnMissingInterpolator)) // among Xlint + assertFalse(check("-Xlint:-warn-missing-interpolator")(_.warnMissingInterpolator)) + assertFalse(check("-Xlint:-warn-missing-interpolator", "-Xlint")(_.warnMissingInterpolator)) + // two lint settings are first come etc; unlike -Y + assertTrue(check("-Xlint", "-Xlint:-warn-missing-interpolator")(_.warnMissingInterpolator)) + } } From 70afd0544e86456515caee62a3eaac41882d892f Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Sat, 28 Jun 2014 19:12:48 +0200 Subject: [PATCH 380/826] relaxes attachment-matching rules It came as a surprise recently, but attachments.contains/get/update/remove require the class of the payload to match the provided tag exactly, not taking subclassing into account. This commit fixes the oversight. --- .../scala/reflect/macros/Attachments.scala | 2 +- .../pos/macro-attachments/Macros_1.scala | 19 +++++++++++++++++++ test/files/pos/macro-attachments/Test_2.scala | 3 +++ test/files/run/reflection-attachments.check | 0 4 files changed, 23 insertions(+), 1 deletion(-) create mode 100644 test/files/pos/macro-attachments/Macros_1.scala create mode 100644 test/files/pos/macro-attachments/Test_2.scala create mode 100644 test/files/run/reflection-attachments.check diff --git a/src/reflect/scala/reflect/macros/Attachments.scala b/src/reflect/scala/reflect/macros/Attachments.scala index 5ccdc15a03f4..b5c340645a64 100644 --- a/src/reflect/scala/reflect/macros/Attachments.scala +++ b/src/reflect/scala/reflect/macros/Attachments.scala @@ -35,7 +35,7 @@ abstract class Attachments { self => def all: Set[Any] = Set.empty private def matchesTag[T: ClassTag](datum: Any) = - classTag[T].runtimeClass == datum.getClass + classTag[T].runtimeClass.isInstance(datum) /** An underlying payload of the given class type `T`. */ def get[T: ClassTag]: Option[T] = diff --git a/test/files/pos/macro-attachments/Macros_1.scala b/test/files/pos/macro-attachments/Macros_1.scala new file mode 100644 index 000000000000..38d05d5b85db --- /dev/null +++ b/test/files/pos/macro-attachments/Macros_1.scala @@ -0,0 +1,19 @@ +import scala.language.experimental.macros +import scala.reflect.macros.whitebox.Context + +trait Base +class Att extends Base + +object Macros { + def impl(c: Context) = { + import c.universe._ + import c.internal._ + import decorators._ + val dummy = q"x" + dummy.updateAttachment(new Att) + if (dummy.attachments.get[Base].isEmpty) c.abort(c.enclosingPosition, "that's not good") + q"()" + } + + def foo: Any = macro impl +} \ No newline at end of file diff --git a/test/files/pos/macro-attachments/Test_2.scala b/test/files/pos/macro-attachments/Test_2.scala new file mode 100644 index 000000000000..acfddae94215 --- /dev/null +++ b/test/files/pos/macro-attachments/Test_2.scala @@ -0,0 +1,3 @@ +object Test extends App { + Macros.foo +} \ No newline at end of file diff --git a/test/files/run/reflection-attachments.check b/test/files/run/reflection-attachments.check new file mode 100644 index 000000000000..e69de29bb2d1 From 5ba2be24f82631f10d9163513204c5e44f445555 Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Sat, 28 Jun 2014 18:46:54 +0200 Subject: [PATCH 381/826] prevents some reflection APIs from destroying rangeposes This commit continues the work started in fcb3932b32. As we've figured out the hard way, exposing internally maintained trees (e.g. macro application) to the user is dangerous, because they can mutate the trees in place using one of the public APIs, potentially corrupting our internal state. Therefore, at some point we started duplicating everything that comes from the user and goes back to the user. This was generally a good idea due to the reason described above, but there was a problem that we didn't foresee - the problem of corrupted positions. It turns out that Tree.duplicate focuses positions in the tree being processed, turning range positions into offset ones, and that makes it impossible for macro users to make use of precise position information. I also went through the calls to Tree.duplicate to see what can be done to them. In cases when corruptions could happen, I tried to replace duplicate with duplicateAndKeepPositions. Some notes: 1) Tree rehashing performed in TreeGen uses duplicates here and there (e.g. in mkTemplate or in mkFor), which means that if one deconstructs a macro argument and then constructs it back, some of the positions in synthetic trees might become inaccurate. That's a general problem with synthetic trees though, so I don't think it should be addressed here. 2) TypeTree.copyAttrs does duplication of originals, which means that even duplicateAndKeepPositions will adversely affect positions of certain publicly accessible parts of type trees. I'm really scared to change this though, because who knows who can use this invariant. 3) Some methods that can be reached from the public API (Tree.substituteXXX, c.reifyXXX, c.untypecheck, ...) do duplicate internally, but that shouldn't be a big problem for us, because nothing is irreversibly corrupted here. It's the user's choice to call those methods (unlike with TypeTree.copyAttrs) and, if necessary, they can fixup the positions themselves afterwards. 4) Macro engine internals (macro impl binding creation, exploratory typechecking in typedMacroBody) use duplicate, but these aren't supposed to be seen by the user, so this shouldn't be a problem. 5) Certain parser functions, member syntheses and typer desugarings also duplicate, but in those cases we aren't talking about taking user trees and screwing them up, but rather about emitting potentially imprecise positions in the first place. Hence this commit isn't the right place to address these potential issues. --- .../scala/reflect/internal/Internals.scala | 2 +- .../files/run/macro-rangepos-subpatterns.check | 1 + .../files/run/macro-rangepos-subpatterns.flags | 1 + .../macro-rangepos-subpatterns/Macros_1.scala | 18 ++++++++++++++++++ .../macro-rangepos-subpatterns/Test_2.scala | 5 +++++ 5 files changed, 26 insertions(+), 1 deletion(-) create mode 100644 test/files/run/macro-rangepos-subpatterns.check create mode 100644 test/files/run/macro-rangepos-subpatterns.flags create mode 100644 test/files/run/macro-rangepos-subpatterns/Macros_1.scala create mode 100644 test/files/run/macro-rangepos-subpatterns/Test_2.scala diff --git a/src/reflect/scala/reflect/internal/Internals.scala b/src/reflect/scala/reflect/internal/Internals.scala index e9916cf7d11a..26f3bfd9d073 100644 --- a/src/reflect/scala/reflect/internal/Internals.scala +++ b/src/reflect/scala/reflect/internal/Internals.scala @@ -129,7 +129,7 @@ trait Internals extends api.Internals { def typeBounds(lo: Type, hi: Type): TypeBounds = self.TypeBounds(lo, hi) def boundedWildcardType(bounds: TypeBounds): BoundedWildcardType = self.BoundedWildcardType(bounds) - def subpatterns(tree: Tree): Option[List[Tree]] = tree.attachments.get[SubpatternsAttachment].map(_.patterns.map(_.duplicate)) + def subpatterns(tree: Tree): Option[List[Tree]] = tree.attachments.get[SubpatternsAttachment].map(_.patterns.map(duplicateAndKeepPositions)) type Decorators = MacroDecoratorApi lazy val decorators: Decorators = new MacroDecoratorApi { diff --git a/test/files/run/macro-rangepos-subpatterns.check b/test/files/run/macro-rangepos-subpatterns.check new file mode 100644 index 000000000000..760e15d019ba --- /dev/null +++ b/test/files/run/macro-rangepos-subpatterns.check @@ -0,0 +1 @@ +The width of the subpattern is: 2 diff --git a/test/files/run/macro-rangepos-subpatterns.flags b/test/files/run/macro-rangepos-subpatterns.flags new file mode 100644 index 000000000000..fcf951d90723 --- /dev/null +++ b/test/files/run/macro-rangepos-subpatterns.flags @@ -0,0 +1 @@ +-Yrangepos \ No newline at end of file diff --git a/test/files/run/macro-rangepos-subpatterns/Macros_1.scala b/test/files/run/macro-rangepos-subpatterns/Macros_1.scala new file mode 100644 index 000000000000..0f30862347b6 --- /dev/null +++ b/test/files/run/macro-rangepos-subpatterns/Macros_1.scala @@ -0,0 +1,18 @@ +import scala.reflect.macros.whitebox.Context +import language.experimental.macros + +object Extractor { + def unapply(x: Any): Any = macro unapplyImpl + def unapplyImpl(c: Context)(x: c.Tree) = { + import c.universe._ + import internal._ + val pos = subpatterns(x).get.head.pos + q""" + new { + def isEmpty = false + def get = ${"The width of the subpattern is: " + (pos.end - pos.start + 1)} + def unapply(x: Any) = this + }.unapply($x) + """ + } +} diff --git a/test/files/run/macro-rangepos-subpatterns/Test_2.scala b/test/files/run/macro-rangepos-subpatterns/Test_2.scala new file mode 100644 index 000000000000..7b076e663239 --- /dev/null +++ b/test/files/run/macro-rangepos-subpatterns/Test_2.scala @@ -0,0 +1,5 @@ +object Test extends App { + 42 match { + case Extractor(a) => println(a) + } +} From 3b89c168b4926139f7295183fdc1903f6f553798 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Tue, 1 Jul 2014 08:21:07 -0700 Subject: [PATCH 382/826] SI-8525 No anonymous lint Turn anonymous references to `settings.lint` into named settings. After that, trust to Adriaan to make them filterable. There are a few remaining top-level -Y lint warnings that are deprecated. --- .../scala/tools/nsc/plugins/Plugins.scala | 2 +- .../scala/tools/nsc/settings/Warnings.scala | 97 ++++++++++++++++--- .../nsc/transform/patmat/MatchAnalysis.scala | 2 +- .../scala/tools/nsc/typechecker/Namers.scala | 2 +- .../tools/nsc/typechecker/RefChecks.scala | 8 +- .../nsc/typechecker/SuperAccessors.scala | 2 +- .../nsc/typechecker/SyntheticMethods.scala | 11 +-- .../tools/nsc/doc/ScaladocAnalyzer.scala | 2 +- test/files/neg/t4851.flags | 2 +- test/files/neg/t8525.check | 11 ++- test/files/neg/t8525.flags | 2 +- test/files/neg/t8610-arg.check | 8 +- test/files/neg/warn-inferred-any.flags | 2 +- test/files/run/t8610.check | 3 + test/files/run/t8610.flags | 2 +- .../tools/nsc/settings/SettingsTest.scala | 6 +- 16 files changed, 122 insertions(+), 40 deletions(-) diff --git a/src/compiler/scala/tools/nsc/plugins/Plugins.scala b/src/compiler/scala/tools/nsc/plugins/Plugins.scala index 12f9aeba2728..6e3d013e52b7 100644 --- a/src/compiler/scala/tools/nsc/plugins/Plugins.scala +++ b/src/compiler/scala/tools/nsc/plugins/Plugins.scala @@ -33,7 +33,7 @@ trait Plugins { global: Global => } val maybes = Plugin.loadAllFrom(paths, dirs, settings.disable.value) val (goods, errors) = maybes partition (_.isSuccess) - // Explicit parameterization of recover to suppress -Xlint warning about inferred Any + // Explicit parameterization of recover to avoid -Xlint warning about inferred Any errors foreach (_.recover[Any] { // legacy behavior ignores altogether, so at least warn devs case e: MissingPluginException => if (global.isDeveloper) warning(e.getMessage) diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala index f1ed45a2a0b6..3ff2369f860d 100644 --- a/src/compiler/scala/tools/nsc/settings/Warnings.scala +++ b/src/compiler/scala/tools/nsc/settings/Warnings.scala @@ -34,34 +34,76 @@ trait Warnings { warnInferAny, // warnUnused SI-7712, SI-7707 warnUnused not quite ready for prime-time // warnUnusedImport currently considered too noisy for general use - warnMissingInterpolator + // warnValueOverrides + warnMissingInterpolator, + warnDocDetached, + warnPrivateShadow, + warnPolyImplicitOverload, + warnOptionImplicit, + warnDelayedInit, + warnByNameRightAssociative, + warnPackageObjectClasses, + warnUnsoundMatch ) private lazy val warnSelectNullable = BooleanSetting("-Xcheck-null", "This option is obsolete and does nothing.") // Individual warnings. - val warnAdaptedArgs = BooleanSetting ("-Ywarn-adapted-args", "Warn if an argument list is modified to match the receiver.") - val warnDeadCode = BooleanSetting ("-Ywarn-dead-code", "Warn when dead code is identified.") - val warnValueDiscard = BooleanSetting ("-Ywarn-value-discard", "Warn when non-Unit expression results are unused.") - val warnNumericWiden = BooleanSetting ("-Ywarn-numeric-widen", "Warn when numerics are widened.") - val warnNullaryUnit = BooleanSetting ("-Ywarn-nullary-unit", "Warn when nullary methods return Unit.") - val warnInaccessible = BooleanSetting ("-Ywarn-inaccessible", "Warn about inaccessible types in method signatures.") - val warnNullaryOverride = BooleanSetting ("-Ywarn-nullary-override", "Warn when non-nullary overrides nullary, e.g. `def foo()` over `def foo`.") - val warnInferAny = BooleanSetting ("-Ywarn-infer-any", "Warn when a type argument is inferred to be `Any`.") - val warnUnused = BooleanSetting ("-Ywarn-unused", "Warn when local and private vals, vars, defs, and types are are unused") - val warnUnusedImport = BooleanSetting ("-Ywarn-unused-import", "Warn when imports are unused") + val warnDeadCode = BooleanSetting("-Ywarn-dead-code", + "Warn when dead code is identified.") + val warnValueDiscard = BooleanSetting("-Ywarn-value-discard", + "Warn when non-Unit expression results are unused.") + val warnNumericWiden = BooleanSetting("-Ywarn-numeric-widen", + "Warn when numerics are widened.") + val warnUnused = BooleanSetting("-Ywarn-unused", + "Warn when local and private vals, vars, defs, and types are are unused") + val warnUnusedImport = BooleanSetting("-Ywarn-unused-import", + "Warn when imports are unused") - // Lint warnings that are not -Y - val warnMissingInterpolator = new BooleanSetting("warn-missing-interpolator", "Warn when a string literal appears to be missing an interpolator id.") + // Lint warnings that are not -Y, created with new instead of autoregistering factory method + private def lintflag(name: String, text: String) = new BooleanSetting(name, text) + + val warnAdaptedArgs = lintflag("adapted-args", + "Warn if an argument list is modified to match the receiver.") + val warnNullaryUnit = lintflag("nullary-unit", + "Warn when nullary methods return Unit.") + val warnInaccessible = lintflag("inaccessible", + "Warn about inaccessible types in method signatures.") + val warnNullaryOverride = lintflag("nullary-override", + "Warn when non-nullary `def f()' overrides nullary `def f'.") + val warnInferAny = lintflag("infer-any", + "Warn when a type argument is inferred to be `Any`.") + val warnMissingInterpolator = lintflag("missing-interpolator", + "A string literal appears to be missing an interpolator id.") + val warnDocDetached = lintflag("doc-detached", + "A ScalaDoc comment appears to be detached from its element.") + val warnPrivateShadow = lintflag("private-shadow", + "A private field (or class parameter) shadows a superclass field.") + val warnPolyImplicitOverload = lintflag("poly-implicit-overload", + "Parameterized overloaded implicit methods are not visible as view bounds") + val warnOptionImplicit = lintflag("option-implicit", + "Option.apply used implicit view.") + val warnDelayedInit = lintflag("delayedinit-select", + "Selecting member of DelayedInit") + val warnByNameRightAssociative = lintflag("by-name-right-associative", + "By-name parameter of right associative operator") + val warnPackageObjectClasses = lintflag("package-object-classes", + "Class or object defined in package object") + val warnUnsoundMatch = lintflag("unsound-match", + "Pattern match may not be typesafe") + + // Lint warnings that are not enabled yet + val warnValueOverrides = lintflag("value-overrides", "Generated value class method overrides an implementation") // Warning groups. val lint = { // Boolean setting for testing if lint is on; not "added" to option processing - val xlint = new BooleanSetting("-Xlint", "Enable recommended additional warnings.") - def lintables = (lintWarnings map (_.name stripPrefix "-Y")).sorted + val xlint = lintflag("-Xlint", "Enable recommended additional warnings.") + val yprefix = "-Ywarn-" + def lintables = (lintWarnings map (_.name stripPrefix yprefix)).sorted def isAnon(b: BooleanSetting) = !(b.name startsWith "-") def setPolitely(b: BooleanSetting, v: Boolean) = if (!b.isSetByUser) b.value = v - def set(w: String, v: Boolean) = lintWarnings find (_.name.stripPrefix("-Y") == w) foreach (b => setPolitely(b, v)) + def set(w: String, v: Boolean) = lintWarnings find (s => (s.name stripPrefix yprefix) == w) foreach (b => setPolitely(b, v)) val Neg = "-" def propagate(ss: List[String]): Unit = ss match { case w :: rest => if (w startsWith Neg) set(w stripPrefix Neg, false) else set(w, true) ; propagate(rest) @@ -81,6 +123,29 @@ trait Warnings { xlint } + // Lint warnings that are currently -Y, but deprecated in that usage + // Alas, the -Yarg must have a doppelgaenger that is not deprecated + @deprecated("Use the Xlint flag", since="2.11.2") + val YwarnAdaptedArgs = BooleanSetting("-Ywarn-adapted-args", + "Warn if an argument list is modified to match the receiver.") withDeprecationMessage + "Enable -Xlint:adapted-args" enabling List(warnAdaptedArgs) + @deprecated("Use the Xlint flag", since="2.11.2") + val YwarnNullaryUnit = BooleanSetting("-Ywarn-nullary-unit", + "Warn when nullary methods return Unit.") withDeprecationMessage + "Enable -Xlint:nullary-unit" enabling List(warnNullaryUnit) + @deprecated("Use the Xlint flag", since="2.11.2") + val YwarnInaccessible = BooleanSetting("-Ywarn-inaccessible", + "Warn about inaccessible types in method signatures.") withDeprecationMessage + "Enable -Xlint:inaccessible" enabling List(warnInaccessible) + @deprecated("Use the Xlint flag", since="2.11.2") + val YwarnNullaryOverride = BooleanSetting("-Ywarn-nullary-override", + "Warn when non-nullary `def f()' overrides nullary `def f'.") withDeprecationMessage + "Enable -Xlint:nullary-override" enabling List(warnNullaryOverride) + @deprecated("Use the Xlint flag", since="2.11.2") + val YwarnInferAny = BooleanSetting("-Ywarn-infer-any", + "Warn when a type argument is inferred to be `Any`.") withDeprecationMessage + "Enable -Xlint:infer-any" enabling List(warnInferAny) + // Backward compatibility. @deprecated("Use fatalWarnings", "2.11.0") def Xwarnfatal = fatalWarnings // used by sbt @deprecated("This option is being removed", "2.11.0") def Xchecknull = warnSelectNullable // used by ide diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala index 6f81cbe15230..b2dc6e4e52e0 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchAnalysis.scala @@ -50,7 +50,7 @@ trait TreeAndTypeAnalysis extends Debugging { // but the annotation didn't bubble up... // This is a pretty poor approximation. def unsoundAssumptionUsed = binder.name != nme.WILDCARD && !(pt <:< pat.tpe) - if (settings.lint && unsoundAssumptionUsed) + if (settings.warnUnsoundMatch && unsoundAssumptionUsed) reporter.warning(pat.pos, sm"""The value matched by $pat is bound to ${binder.name}, which may be used under the |unsound assumption that it has type ${pat.tpe}, whereas we can only safely diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index 1328119aacf7..7bbd81118aa1 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -717,7 +717,7 @@ trait Namers extends MethodSynthesis { m.updateAttachment(new ConstructorDefaultsAttachment(tree, null)) } val owner = tree.symbol.owner - if (settings.lint && owner.isPackageObjectClass && !mods.isImplicit) { + if (settings.warnPackageObjectClasses && owner.isPackageObjectClass && !mods.isImplicit) { reporter.warning(tree.pos, "it is not recommended to define classes/objects inside of package objects.\n" + "If possible, define " + tree.symbol + " in " + owner.skipPackageObject + " instead." diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index 1b3da26bf293..47465875e933 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -167,7 +167,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans } // This has become noisy with implicit classes. - if (settings.lint && settings.developer) { + if (settings.warnPolyImplicitOverload && settings.developer) { clazz.info.decls filter (x => x.isImplicit && x.typeParams.nonEmpty) foreach { sym => // implicit classes leave both a module symbol and a method symbol as residue val alts = clazz.info.decl(sym.name).alternatives filterNot (_.isModule) @@ -954,7 +954,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans def apply(tp: Type) = mapOver(tp).normalize } - def checkImplicitViewOptionApply(pos: Position, fn: Tree, args: List[Tree]): Unit = if (settings.lint) (fn, args) match { + def checkImplicitViewOptionApply(pos: Position, fn: Tree, args: List[Tree]): Unit = if (settings.warnOptionImplicit) (fn, args) match { case (tap@TypeApply(fun, targs), List(view: ApplyImplicitView)) if fun.symbol == currentRun.runDefinitions.Option_apply => reporter.warning(pos, s"Suspicious application of an implicit view (${view.fun}) in the argument to Option.apply.") // SI-6567 case _ => @@ -1320,7 +1320,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans && !qual.tpe.isInstanceOf[ThisType] && sym.accessedOrSelf.isVal ) - if (settings.lint.value && isLikelyUninitialized) + if (settings.warnDelayedInit && isLikelyUninitialized) reporter.warning(pos, s"Selecting ${sym} from ${sym.owner}, which extends scala.DelayedInit, is likely to yield an uninitialized value") } @@ -1387,7 +1387,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans private def checkByNameRightAssociativeDef(tree: DefDef) { tree match { case DefDef(_, name, _, params :: _, _, _) => - if (settings.lint && !treeInfo.isLeftAssoc(name.decodedName) && params.exists(p => isByName(p.symbol))) + if (settings.warnByNameRightAssociative && !treeInfo.isLeftAssoc(name.decodedName) && params.exists(p => isByName(p.symbol))) reporter.warning(tree.pos, "by-name parameters will be evaluated eagerly when called as a right-associative infix operator. For more details, see SI-1980.") case _ => diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala index d3a41b9570ca..38b00a015bac 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala @@ -247,7 +247,7 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT // also exists in a superclass, because they may be surprised // to find out that a constructor parameter will shadow a // field. See SI-4762. - if (settings.lint) { + if (settings.warnPrivateShadow) { if (sym.isPrivateLocal && sym.paramss.isEmpty) { qual.symbol.ancestors foreach { parent => parent.info.decls filterNot (x => x.isPrivate || x.isLocalToThis) foreach { m2 => diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala index 9516f9413590..d0237fb46813 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala @@ -339,12 +339,11 @@ trait SyntheticMethods extends ast.TreeDSL { !hasOverridingImplementation(m) || { clazz.isDerivedValueClass && (m == Any_hashCode || m == Any_equals) && { // Without a means to suppress this warning, I've thought better of it. - // - // if (settings.lint) { - // (clazz.info nonPrivateMember m.name) filter (m => (m.owner != AnyClass) && (m.owner != clazz) && !m.isDeferred) andAlso { m => - // currentUnit.warning(clazz.pos, s"Implementation of ${m.name} inherited from ${m.owner} overridden in $clazz to enforce value class semantics") - // } - // } + if (settings.warnValueOverrides) { + (clazz.info nonPrivateMember m.name) filter (m => (m.owner != AnyClass) && (m.owner != clazz) && !m.isDeferred) andAlso { m => + currentUnit.warning(clazz.pos, s"Implementation of ${m.name} inherited from ${m.owner} overridden in $clazz to enforce value class semantics") + } + } true } } diff --git a/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala b/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala index 10c382e16987..ccf18b76de52 100644 --- a/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala +++ b/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala @@ -190,7 +190,7 @@ abstract class ScaladocSyntaxAnalyzer[G <: Global](val global: G) extends Syntax typeParams.nonEmpty || version.nonEmpty || since.nonEmpty } def isDirty = unclean(unmooredParser parseComment doc) - if ((doc ne null) && (settings.lint || isDirty)) + if ((doc ne null) && (settings.warnDocDetached || isDirty)) reporter.warning(doc.pos, "discarding unmoored doc comment") } diff --git a/test/files/neg/t4851.flags b/test/files/neg/t4851.flags index ca0d0a0ba31b..044ce22c8403 100644 --- a/test/files/neg/t4851.flags +++ b/test/files/neg/t4851.flags @@ -1 +1 @@ --Ywarn-adapted-args -Xfatal-warnings -deprecation +-Xlint:adapted-args -Xfatal-warnings -deprecation diff --git a/test/files/neg/t8525.check b/test/files/neg/t8525.check index 554ab23253e4..5287e43b7a91 100644 --- a/test/files/neg/t8525.check +++ b/test/files/neg/t8525.check @@ -1,6 +1,15 @@ +t8525.scala:7: warning: Adapting argument list by creating a 2-tuple: this may not be what you want. + signature: X.f(p: (Int, Int)): Int + given arguments: 3, 4 + after adaptation: X.f((3, 4): (Int, Int)) + def g = f(3, 4) // adapted + ^ t8525.scala:9: warning: private[this] value name in class X shadows mutable name inherited from class Named. Changes to name will not be visible within class X - you may want to give them distinct names. override def toString = name // shadowing mutable var name ^ +t8525.scala:8: warning: side-effecting nullary methods are discouraged: suggest defining as `def u()` instead + def u: Unit = () // unitarian universalist + ^ error: No warnings can be incurred under -Xfatal-warnings. -one warning found +three warnings found one error found diff --git a/test/files/neg/t8525.flags b/test/files/neg/t8525.flags index f19af1f71739..53b2dfe7ec81 100644 --- a/test/files/neg/t8525.flags +++ b/test/files/neg/t8525.flags @@ -1 +1 @@ --Xfatal-warnings -Xlint:-warn-missing-interpolator +-Xfatal-warnings -Xlint:-missing-interpolator -Xlint diff --git a/test/files/neg/t8610-arg.check b/test/files/neg/t8610-arg.check index 4f194ce84a00..ea2805508dbd 100644 --- a/test/files/neg/t8610-arg.check +++ b/test/files/neg/t8610-arg.check @@ -1,6 +1,12 @@ t8610-arg.scala:5: warning: possible missing interpolator: detected interpolated identifier `$name` def x = "Hi, $name" // missing interp ^ +t8610-arg.scala:7: warning: Adapting argument list by creating a 2-tuple: this may not be what you want. + signature: X.f(p: (Int, Int)): Int + given arguments: 3, 4 + after adaptation: X.f((3, 4): (Int, Int)) + def g = f(3, 4) // adapted + ^ t8610-arg.scala:9: warning: private[this] value name in class X shadows mutable name inherited from class Named. Changes to name will not be visible within class X - you may want to give them distinct names. override def toString = name // shadowing mutable var name ^ @@ -8,5 +14,5 @@ t8610-arg.scala:8: warning: side-effecting nullary methods are discouraged: sugg def u: Unit = () // unitarian universalist ^ error: No warnings can be incurred under -Xfatal-warnings. -three warnings found +four warnings found one error found diff --git a/test/files/neg/warn-inferred-any.flags b/test/files/neg/warn-inferred-any.flags index a3127d392a24..b580dfbbe3d7 100644 --- a/test/files/neg/warn-inferred-any.flags +++ b/test/files/neg/warn-inferred-any.flags @@ -1 +1 @@ --Xfatal-warnings -Ywarn-infer-any +-Xfatal-warnings -Xlint:infer-any diff --git a/test/files/run/t8610.check b/test/files/run/t8610.check index 0e0dfc2cd343..fde82d5109dc 100644 --- a/test/files/run/t8610.check +++ b/test/files/run/t8610.check @@ -7,4 +7,7 @@ t8610.scala:6: warning: Adapting argument list by creating a 2-tuple: this may n after adaptation: X.f((3, 4): (Int, Int)) def g = f(3, 4) // adapted ^ +t8610.scala:7: warning: side-effecting nullary methods are discouraged: suggest defining as `def u()` instead + def u: Unit = () // unitarian universalist + ^ Hi, $name diff --git a/test/files/run/t8610.flags b/test/files/run/t8610.flags index edcb5f4d0c54..4195dec3835a 100644 --- a/test/files/run/t8610.flags +++ b/test/files/run/t8610.flags @@ -1 +1 @@ --Xlint:warn-adapted-args +-Xlint:adapted-args diff --git a/test/junit/scala/tools/nsc/settings/SettingsTest.scala b/test/junit/scala/tools/nsc/settings/SettingsTest.scala index 29591727a31e..9203054d9a15 100644 --- a/test/junit/scala/tools/nsc/settings/SettingsTest.scala +++ b/test/junit/scala/tools/nsc/settings/SettingsTest.scala @@ -58,9 +58,9 @@ class SettingsTest { } @Test def anonymousLintersCanBeNamed() { assertTrue(check("-Xlint")(_.warnMissingInterpolator)) // among Xlint - assertFalse(check("-Xlint:-warn-missing-interpolator")(_.warnMissingInterpolator)) - assertFalse(check("-Xlint:-warn-missing-interpolator", "-Xlint")(_.warnMissingInterpolator)) + assertFalse(check("-Xlint:-missing-interpolator")(_.warnMissingInterpolator)) + assertFalse(check("-Xlint:-missing-interpolator", "-Xlint")(_.warnMissingInterpolator)) // two lint settings are first come etc; unlike -Y - assertTrue(check("-Xlint", "-Xlint:-warn-missing-interpolator")(_.warnMissingInterpolator)) + assertTrue(check("-Xlint", "-Xlint:-missing-interpolator")(_.warnMissingInterpolator)) } } From c39c693f81cdf4d86a6c13bee48fcbc4006fb3bc Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 10 Jul 2014 13:03:26 +0200 Subject: [PATCH 383/826] SI-8117 Fix bug when mixing well-positioned named and positional args The method `missingParams` which returns undefined parameters of a given invocation expression still assumed that named arguments can only appear after positional ones. --- .../tools/nsc/typechecker/NamesDefaults.scala | 41 ++++++++++++++----- test/files/run/names-defaults.check | 1 + test/files/run/names-defaults.scala | 4 ++ 3 files changed, 35 insertions(+), 11 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala index 43902d1c65b9..b6387fd56ba3 100644 --- a/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala +++ b/src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala @@ -379,18 +379,37 @@ trait NamesDefaults { self: Analyzer => def makeNamedTypes(syms: List[Symbol]) = syms map (sym => NamedType(sym.name, sym.tpe)) - def missingParams[T](args: List[T], params: List[Symbol], argName: T => Option[Name] = nameOfNamedArg _): (List[Symbol], Boolean) = { - val namedArgs = args.dropWhile(arg => { - val n = argName(arg) - n.isEmpty || params.forall(p => p.name != n.get) - }) - val namedParams = params.drop(args.length - namedArgs.length) - // missing: keep those with a name which doesn't exist in namedArgs - val missingParams = namedParams.filter(p => namedArgs.forall(arg => { + /** + * Returns the parameter symbols of an invocation expression that are not defined by the list + * of arguments. + * + * @param args The list of arguments + * @param params The list of parameter sybols of the invoked method + * @param argName A function that extracts the name of an argument expression, if it is a named argument. + */ + def missingParams[T](args: List[T], params: List[Symbol], argName: T => Option[Name]): (List[Symbol], Boolean) = { + // The argument list contains first a mix of positional args and named args that are on the + // right parameter position, and then a number or named args on different positions. + + // collect all named arguments whose position does not match the parameter they define + val namedArgsOnChangedPosition = args.zip(params) dropWhile { + case (arg, param) => + val n = argName(arg) + // drop the argument if + // - it's not named, or + // - it's named, but defines the parameter on its current position, or + // - it's named, but none of the parameter names matches (treated as a positional argument, an assignment expression) + n.isEmpty || n.get == param.name || params.forall(_.name != n.get) + } map (_._1) + + val paramsWithoutPositionalArg = params.drop(args.length - namedArgsOnChangedPosition.length) + + // missing parameters: those with a name which is not specified in one of the namedArgsOnChangedPosition + val missingParams = paramsWithoutPositionalArg.filter(p => namedArgsOnChangedPosition.forall { arg => val n = argName(arg) n.isEmpty || n.get != p.name - })) - val allPositional = missingParams.length == namedParams.length + }) + val allPositional = missingParams.length == paramsWithoutPositionalArg.length (missingParams, allPositional) } @@ -407,7 +426,7 @@ trait NamesDefaults { self: Analyzer => previousArgss: List[List[Tree]], params: List[Symbol], pos: scala.reflect.internal.util.Position, context: Context): (List[Tree], List[Symbol]) = { if (givenArgs.length < params.length) { - val (missing, positional) = missingParams(givenArgs, params) + val (missing, positional) = missingParams(givenArgs, params, nameOfNamedArg) if (missing forall (_.hasDefault)) { val defaultArgs = missing flatMap (p => { val defGetter = defaultGetter(p, context) diff --git a/test/files/run/names-defaults.check b/test/files/run/names-defaults.check index 25999c488aff..c358dc5849de 100644 --- a/test/files/run/names-defaults.check +++ b/test/files/run/names-defaults.check @@ -124,3 +124,4 @@ List(1, 2) 3 3 (1,0), (1,2) +1 1 0 diff --git a/test/files/run/names-defaults.scala b/test/files/run/names-defaults.scala index 05cd4a540ca1..b7ed490cbca2 100644 --- a/test/files/run/names-defaults.scala +++ b/test/files/run/names-defaults.scala @@ -401,6 +401,10 @@ object Test extends App { C4441a().copy() C4441b()().copy()() + // SI-8117 + def f8177(a: Int = 0, b: Int = 0, c: Int = 0) = s"$a $b $c" + println(f8177(a = 1, 1)) + // DEFINITIONS def test1(a: Int, b: String) = println(a +": "+ b) def test2(u: Int, v: Int)(k: String, l: Int) = println(l +": "+ k +", "+ (u + v)) From f36e7008937a1672c0e57dbf2eefe7a80e8988d7 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Fri, 11 Jul 2014 11:05:59 +0200 Subject: [PATCH 384/826] SI-8710 Fix crasher for value classes + private + overloading The link between methods owned by a value class and the corresponding extension method in the companion is governed in part by a naming convention that depends on how many eponymous decls exist. This is easiest to explain with an example: % cat sandbox/test.scala && \ qscalac -Xprint:extmethods sandbox/test.scala \ | egrep 'class|object|def (foo|bar)|}$' class C(val x: Any) extends AnyVal { def foo(a: Int) = "" def foo(a: String) = "" def bar(a: Byte) } final class C extends scala.AnyVal { def foo(a: Int): String = C.foo$extension0(C.this)(a); def foo(a: String): String = C.foo$extension1(C.this)(a); def bar(a: Byte): Unit = C.bar$extension(C.this)(a); } object C extends AnyRef { final def foo$extension0($this: C)(a: Int): String = ""; final def foo$extension1($this: C)(a: String): String = ""; final def bar$extension($this: C)(a: Byte): Unit = (.asInstanceOf[Unit]: Unit); } } } Notice how the extension method names for `foo` are suffixed with a counter. This logic is contained in `extensionNames`. However, in the enclosed test cases, when we call `extensionNames` in a late phase of the compiler, in particular during erasure when we rewire `new C(x).foo(args)` to `C.foo$extensionN(x)(args)`, we crash. Why? The private method in the value class has been name mangled by `ExplicitOuter`'s use of `makeNotPrivate`, and we no longer appear to have multiple eponymous methods in play. We could try to fix this by changing `extensionNames` to poke around through the scopes of the value class and its companion in a manner insensitive to expanded names. This might look something like: - info.decl(imeth.name) + newOverloadedSymbol(info.decls.filter(sym => unexpandedName(sym) == unexpandedName(imeth.name)) But in fact we never need to expand the name of a private method in an value class, nor its corresponding companion, as: - calls to private value class members end up as calls to public extension methods - extension methods already have a the `$extension[N]` suffix and need no further mangling. This commit: - Resets `PRIVATE` and `LOCAL` when deriving the extension method - Adds a special case to `ExplicitOuter` to imbue the special knowledge that a call to `SomeValueClass#somePrivateMethod` need not `makeNotPrivate`, as erasure will come along later and rewire that to a (public) extension method. --- .../tools/nsc/transform/ExplicitOuter.scala | 6 ++++-- .../tools/nsc/transform/ExtensionMethods.scala | 2 +- test/files/run/t8710.scala | 17 +++++++++++++++++ 3 files changed, 22 insertions(+), 3 deletions(-) create mode 100644 test/files/run/t8710.scala diff --git a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala index 0447e23e9eed..51dd8587194a 100644 --- a/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala +++ b/src/compiler/scala/tools/nsc/transform/ExplicitOuter.scala @@ -446,8 +446,10 @@ abstract class ExplicitOuter extends InfoTransform // // See SI-6552 for an example of why `sym.owner.enclMethod hasAnnotation ScalaInlineClass` // is not suitable; if we make a method-local class non-private, it mangles outer pointer names. - if (currentClass != sym.owner || - (closestEnclMethod(currentOwner) hasAnnotation ScalaInlineClass)) + def enclMethodIsInline = closestEnclMethod(currentOwner) hasAnnotation ScalaInlineClass + // SI-8710 The extension method condition reflects our knowledge that a call to `new Meter(12).privateMethod` + // with later be rewritten (in erasure) to `Meter.privateMethod$extension(12)`. + if ((currentClass != sym.owner || enclMethodIsInline) && !sym.isMethodWithExtension) sym.makeNotPrivate(sym.owner) val qsym = qual.tpe.widen.typeSymbol diff --git a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala index 2235a93ca442..04f1ff48f44b 100644 --- a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala +++ b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala @@ -208,7 +208,7 @@ abstract class ExtensionMethods extends Transform with TypingTransformers { def makeExtensionMethodSymbol = { val extensionName = extensionNames(origMeth).head.toTermName val extensionMeth = ( - companion.moduleClass.newMethod(extensionName, tree.pos.focus, origMeth.flags & ~OVERRIDE & ~PROTECTED | FINAL) + companion.moduleClass.newMethod(extensionName, tree.pos.focus, origMeth.flags & ~OVERRIDE & ~PROTECTED & ~PRIVATE & ~LOCAL | FINAL) setAnnotations origMeth.annotations ) origMeth.removeAnnotation(TailrecClass) // it's on the extension method, now. diff --git a/test/files/run/t8710.scala b/test/files/run/t8710.scala new file mode 100644 index 000000000000..15aab5b8a462 --- /dev/null +++ b/test/files/run/t8710.scala @@ -0,0 +1,17 @@ +class Bar(val x: Int) extends AnyVal { + def f: String = f(0) + private def f(x: Int): String = "" +} + +class Baz(val x: Int) extends AnyVal { + def f: String = "123" + private def f(x: Int): String = "" +} +object Baz { + def x(b: Baz) = b.f(0) +} + +object Test extends App { + new Bar(23).f + new Baz(23).f +} From 13054daa658484df30b71447dbe684f475537252 Mon Sep 17 00:00:00 2001 From: Masato Sogame Date: Sat, 12 Jul 2014 23:47:10 +0900 Subject: [PATCH 385/826] Rewrite explanation of doc-source-url option more clearly, and fix encoding to show euro-sign correctly. --- src/scaladoc/scala/tools/nsc/doc/Settings.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scaladoc/scala/tools/nsc/doc/Settings.scala b/src/scaladoc/scala/tools/nsc/doc/Settings.scala index 67529f417845..02929c5ecb44 100644 --- a/src/scaladoc/scala/tools/nsc/doc/Settings.scala +++ b/src/scaladoc/scala/tools/nsc/doc/Settings.scala @@ -66,7 +66,7 @@ class Settings(error: String => Unit, val printMsg: String => Unit = println(_)) val docsourceurl = StringSetting ( "-doc-source-url", "url", - "A URL pattern used to build links to template sources; use variables, for example: ?{TPL_NAME} ('Seq'), ?{TPL_OWNER} ('scala.collection'), ?{FILE_PATH} ('scala/collection/Seq')", + s"A URL pattern used to link to the source file; the following variables are available: €{TPL_NAME}, €{TPL_OWNER} and respectively €{FILE_PATH}. For example, for `scala.collection.Seq`, the variables will be expanded to `Seq`, `scala.collection` and respectively `scala/collection/Seq` (without the backquotes). To obtain a relative path for €{FILE_PATH} instead of an absolute one, use the ${sourcepath.name} setting.", "" ) From 26b77aca9498775968cc9138c7537dbfbc52e3fd Mon Sep 17 00:00:00 2001 From: Philipp Haller Date: Fri, 11 Jul 2014 17:02:41 +0200 Subject: [PATCH 386/826] SI-8590 Expand doc comments for ExecutionContext - link to Java API docs for ForkJoinPool-based default implementation - add example for creating an execution context from a `java.util.concurrent.ExecutorService` - add tags for parameters and return values - expand doc comment for `prepare` --- .../scala/concurrent/ExecutionContext.scala | 72 +++++++++++++++---- 1 file changed, 60 insertions(+), 12 deletions(-) diff --git a/src/library/scala/concurrent/ExecutionContext.scala b/src/library/scala/concurrent/ExecutionContext.scala index 4674c9174b88..11d3bb8b0265 100644 --- a/src/library/scala/concurrent/ExecutionContext.scala +++ b/src/library/scala/concurrent/ExecutionContext.scala @@ -61,28 +61,44 @@ or import scala.concurrent.ExecutionContext.Implicits.global.""") trait ExecutionContext { /** Runs a block of code on this execution context. + * + * @param runnable the task to execute */ def execute(runnable: Runnable): Unit /** Reports that an asynchronous computation failed. + * + * @param cause the cause of the failure */ def reportFailure(@deprecatedName('t) cause: Throwable): Unit - /** Prepares for the execution of a task. Returns the prepared - * execution context. A valid implementation of `prepare` is one - * that simply returns `this`. + /** Prepares for the execution of a task. Returns the prepared execution context. + * + * `prepare` should be called at the site where an `ExecutionContext` is received (for + * example, through an implicit method parameter). The returned execution context may + * then be used to execute tasks. The role of `prepare` is to save any context relevant + * to an execution's ''call site'', so that this context may be restored at the + * ''execution site''. (These are often different: for example, execution may be + * suspended through a `Promise`'s future until the `Promise` is completed, which may + * be done in another thread, on another stack.) + * + * Note: a valid implementation of `prepare` is one that simply returns `this`. + * + * @return the prepared execution context */ def prepare(): ExecutionContext = this } /** - * An [[ExecutionContext]] that is also a Java [[Executor]]. + * An [[ExecutionContext]] that is also a + * Java [[http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executor.html Executor]]. */ trait ExecutionContextExecutor extends ExecutionContext with Executor /** - * An [[ExecutionContext]] that is also a Java [[ExecutorService]]. + * An [[ExecutionContext]] that is also a + * Java [[http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html ExecutorService]]. */ trait ExecutionContextExecutorService extends ExecutionContextExecutor with ExecutorService @@ -91,38 +107,70 @@ trait ExecutionContextExecutorService extends ExecutionContextExecutor with Exec */ object ExecutionContext { /** - * This is the explicit global ExecutionContext, - * call this when you want to provide the global ExecutionContext explicitly + * The explicit global `ExecutionContext`. Invoke `global` when you want to provide the global + * `ExecutionContext` explicitly. + * + * The default `ExecutionContext` implementation is backed by a port of + * [[http://gee.cs.oswego.edu/dl/jsr166/dist/jsr166-4jdk7docs/java/util/concurrent/ForkJoinPool.html java.util.concurrent.ForkJoinPool]]. + * + * @return the global `ExecutionContext` */ def global: ExecutionContextExecutor = Implicits.global object Implicits { /** - * This is the implicit global ExecutionContext, - * import this when you want to provide the global ExecutionContext implicitly + * The implicit global `ExecutionContext`. Import `global` when you want to provide the global + * `ExecutionContext` implicitly. + * + * The default `ExecutionContext` implementation is backed by a port of + * [[http://gee.cs.oswego.edu/dl/jsr166/dist/jsr166-4jdk7docs/java/util/concurrent/ForkJoinPool.html java.util.concurrent.ForkJoinPool]]. */ implicit lazy val global: ExecutionContextExecutor = impl.ExecutionContextImpl.fromExecutor(null: Executor) } /** Creates an `ExecutionContext` from the given `ExecutorService`. + * + * @param e the `ExecutorService` to use + * @param reporter a function for error reporting + * @return the `ExecutionContext` using the given `ExecutorService` */ def fromExecutorService(e: ExecutorService, reporter: Throwable => Unit): ExecutionContextExecutorService = impl.ExecutionContextImpl.fromExecutorService(e, reporter) - /** Creates an `ExecutionContext` from the given `ExecutorService` with the default Reporter. + /** Creates an `ExecutionContext` from the given `ExecutorService` with the [[scala.concurrent.ExecutionContext$.defaultReporter default reporter]]. + * + * If it is guaranteed that none of the executed tasks are blocking, a single-threaded `ExecutorService` + * can be used to create an `ExecutionContext` as follows: + * + * {{{ + * import java.util.concurrent.Executors + * val ec = ExecutionContext.fromExecutorService(Executors.newSingleThreadExecutor()) + * }}} + * + * @param e the `ExecutorService` to use + * @return the `ExecutionContext` using the given `ExecutorService` */ def fromExecutorService(e: ExecutorService): ExecutionContextExecutorService = fromExecutorService(e, defaultReporter) /** Creates an `ExecutionContext` from the given `Executor`. + * + * @param e the `Executor` to use + * @param reporter a function for error reporting + * @return the `ExecutionContext` using the given `Executor` */ def fromExecutor(e: Executor, reporter: Throwable => Unit): ExecutionContextExecutor = impl.ExecutionContextImpl.fromExecutor(e, reporter) - /** Creates an `ExecutionContext` from the given `Executor` with the default Reporter. + /** Creates an `ExecutionContext` from the given `Executor` with the [[scala.concurrent.ExecutionContext$.defaultReporter default reporter]]. + * + * @param e the `Executor` to use + * @return the `ExecutionContext` using the given `Executor` */ def fromExecutor(e: Executor): ExecutionContextExecutor = fromExecutor(e, defaultReporter) - /** The default reporter simply prints the stack trace of the `Throwable` to System.err. + /** The default reporter simply prints the stack trace of the `Throwable` to [[http://docs.oracle.com/javase/8/docs/api/java/lang/System.html#err System.err]]. + * + * @return the function for error reporting */ def defaultReporter: Throwable => Unit = _.printStackTrace() } From 9d527b6558f9ecf32467b6f414175267bb44c1d7 Mon Sep 17 00:00:00 2001 From: Denys Shabalin Date: Mon, 14 Jul 2014 15:22:59 +0200 Subject: [PATCH 387/826] Address pull request feedback --- src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala b/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala index 460d02c2182e..392b7fc8816c 100644 --- a/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala +++ b/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala @@ -72,8 +72,10 @@ trait Parsers { self: Quasiquotes => override def makeBlock(stats: List[Tree]): Tree = method match { case nme.apply => stats match { + // we don't want to eagerly flatten trees with placeholders as they + // might have to be wrapped into a block depending on their value case (head @ Ident(name)) :: Nil if isHole(name) => Block(Nil, head) - case _ => super.makeBlock(stats) + case _ => gen.mkBlock(stats, doFlatten = true) } case nme.unapply => gen.mkBlock(stats, doFlatten = false) case other => global.abort("unreachable") From b0dd01ebb4b0cc41a6629357522217bfe14821fb Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Mon, 14 Jul 2014 07:32:03 -0700 Subject: [PATCH 388/826] SI-8608 f interpolator emits constant strings When invoking `format` is obviated by a lack of formatting fields, then just degenerate to an unenhanced constant string. This means it doesn't cost anything to use f"$$ordinary" in place of "$ordinary", which may cause warnings under -Xlint. Note that certain format literals, in particular for line separator %n, are not actually literals and can't be replaced at compile time. --- .../scala/tools/reflect/FormatInterpolator.scala | 6 ++++-- .../files/run/stringinterpolation_macro-run.check | 4 ++++ .../files/run/stringinterpolation_macro-run.scala | 1 + test/files/run/t8608-no-format.scala | 15 +++++++++++++++ 4 files changed, 24 insertions(+), 2 deletions(-) create mode 100644 test/files/run/t8608-no-format.scala diff --git a/src/compiler/scala/tools/reflect/FormatInterpolator.scala b/src/compiler/scala/tools/reflect/FormatInterpolator.scala index 57be1afdfee1..4fa06be60ff2 100644 --- a/src/compiler/scala/tools/reflect/FormatInterpolator.scala +++ b/src/compiler/scala/tools/reflect/FormatInterpolator.scala @@ -183,11 +183,13 @@ abstract class FormatInterpolator { } //q"{..$evals; ${fstring.toString}.format(..$ids)}" - locally { + val format = fstring.toString + if (ids.isEmpty && !format.contains("%")) Literal(Constant(format)) + else { val expr = Apply( Select( - Literal(Constant(fstring.toString)), + Literal(Constant(format)), newTermName("format")), ids.toList ) diff --git a/test/files/run/stringinterpolation_macro-run.check b/test/files/run/stringinterpolation_macro-run.check index ead61e76aca4..c7f46bac87a8 100644 --- a/test/files/run/stringinterpolation_macro-run.check +++ b/test/files/run/stringinterpolation_macro-run.check @@ -63,5 +63,9 @@ She is 4 feet tall. 05/26/12 05/26/12 % + mind +------ +matter + 7 7 9 7 9 9 diff --git a/test/files/run/stringinterpolation_macro-run.scala b/test/files/run/stringinterpolation_macro-run.scala index a6def9854090..e18375d5217a 100644 --- a/test/files/run/stringinterpolation_macro-run.scala +++ b/test/files/run/stringinterpolation_macro-run.scala @@ -115,6 +115,7 @@ println(f"""${"1234"}%TD""") // literals and arg indexes println(f"%%") +println(f" mind%n------%nmatter%n") println(f"${7}%d % Date: Tue, 15 Jul 2014 00:48:39 +0200 Subject: [PATCH 389/826] Fixes first sentence delimiters Scaladoc places the first sentence in the method summary table and index. The first sentence is defined as the sequence of chars up to the first period (not as in JavaDoc where the sentence ends with the first period *followed by a blank*). As a consequence, the clause starting with `i.e.` is interpreted as sentende delimiter. This request replaces `i.e.` with `i.e.`. Alghough a valid HTML code, I do not know whether this change is compatible with other tools. And I assume that this is not the only source file affected. --- src/library/scala/concurrent/Future.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/library/scala/concurrent/Future.scala b/src/library/scala/concurrent/Future.scala index 4ed068733405..a9b7d79e637c 100644 --- a/src/library/scala/concurrent/Future.scala +++ b/src/library/scala/concurrent/Future.scala @@ -102,7 +102,7 @@ trait Future[+T] extends Awaitable[T] { /* Callbacks */ - /** When this future is completed successfully (i.e. with a value), + /** When this future is completed successfully (i.e. with a value), * apply the provided partial function to the value if the partial function * is defined at that value. * @@ -118,7 +118,7 @@ trait Future[+T] extends Awaitable[T] { case _ => } - /** When this future is completed with a failure (i.e. with a throwable), + /** When this future is completed with a failure (i.e. with a throwable), * apply the provided callback to the throwable. * * $caughtThrowables From 146bdd7073e1184af36d3378595297f3cb92bccf Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Mon, 14 Jul 2014 08:02:41 -0700 Subject: [PATCH 390/826] SI-8608 f-interpolator inlines StringOps Instead of "hi".format(), emit new _root_.s.c.i.StringOps("hi").format(), to clarify intent and avoid picking up some other implicit enhancement. A further optimization would be to use String.format directly when that is possible. The ticket says it is not possible for ``` f"${BigDecimal(3.4)}%e" ``` --- .../scala/tools/reflect/FormatInterpolator.scala | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/src/compiler/scala/tools/reflect/FormatInterpolator.scala b/src/compiler/scala/tools/reflect/FormatInterpolator.scala index 4fa06be60ff2..b445f1e2bbce 100644 --- a/src/compiler/scala/tools/reflect/FormatInterpolator.scala +++ b/src/compiler/scala/tools/reflect/FormatInterpolator.scala @@ -182,15 +182,23 @@ abstract class FormatInterpolator { case (part, n) => copyPart(part, n) } - //q"{..$evals; ${fstring.toString}.format(..$ids)}" + //q"{..$evals; new StringOps(${fstring.toString}).format(..$ids)}" val format = fstring.toString if (ids.isEmpty && !format.contains("%")) Literal(Constant(format)) else { + val scalaPackage = Select(Ident(nme.ROOTPKG), TermName("scala")) + val newStringOps = Select( + New(Select(Select(Select(scalaPackage, + TermName("collection")), TermName("immutable")), TypeName("StringOps"))), + termNames.CONSTRUCTOR + ) val expr = Apply( Select( - Literal(Constant(format)), - newTermName("format")), + Apply( + newStringOps, + List(Literal(Constant(format)))), + TermName("format")), ids.toList ) val p = c.macroApplication.pos From adba40519bc68defb89bf668d814d16447614d9b Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 10 Jul 2014 15:11:04 +0200 Subject: [PATCH 391/826] Fix -Yno-adapted-args, it would just warn, not err --- .../tools/nsc/typechecker/Adaptations.scala | 3 ++- .../scala/tools/nsc/typechecker/Typers.scala | 20 +++++++++--------- test/files/neg/t8035-no-adapted-args.check | 21 +++++++++++++++++++ test/files/neg/t8035-no-adapted-args.flags | 1 + test/files/neg/t8035-no-adapted-args.scala | 6 ++++++ 5 files changed, 40 insertions(+), 11 deletions(-) create mode 100644 test/files/neg/t8035-no-adapted-args.check create mode 100644 test/files/neg/t8035-no-adapted-args.flags create mode 100644 test/files/neg/t8035-no-adapted-args.scala diff --git a/src/compiler/scala/tools/nsc/typechecker/Adaptations.scala b/src/compiler/scala/tools/nsc/typechecker/Adaptations.scala index 37c39c07beaa..2f4d2283476a 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Adaptations.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Adaptations.scala @@ -82,7 +82,8 @@ trait Adaptations { } else if (settings.warnAdaptedArgs) context.warning(t.pos, adaptWarningMessage(s"Adapting argument list by creating a ${args.size}-tuple: this may not be what you want.")) - !settings.noAdaptedArgs || !(args.isEmpty && settings.future) + // return `true` if the adaptation should be kept + !(settings.noAdaptedArgs || (args.isEmpty && settings.future)) } } } diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 2c31ef2e8eab..65f11a360eab 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -3248,25 +3248,25 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper * to that. This is the last thing which is tried (after * default arguments) */ - def tryTupleApply: Tree = ( + def tryTupleApply: Tree = { if (eligibleForTupleConversion(paramTypes, argslen) && !phase.erasedTypes) { val tupleArgs = List(atPos(tree.pos.makeTransparent)(gen.mkTuple(args))) // expected one argument, but got 0 or >1 ==> try applying to tuple // the inner "doTypedApply" does "extractUndetparams" => restore when it fails val savedUndetparams = context.undetparams silent(_.doTypedApply(tree, fun, tupleArgs, mode, pt)) map { t => - // Depending on user options, may warn or error here if - // a Unit or tuple was inserted. - val keepTree = ( - !mode.typingExprNotFun - || t.symbol == null - || checkValidAdaptation(t, args) - ) - if (keepTree) t else EmptyTree + // Depending on user options, may warn or error here if + // a Unit or tuple was inserted. + val keepTree = ( + !mode.typingExprNotFun // why? introduced in 4e488a60, doc welcome + || t.symbol == null // ditto + || checkValidAdaptation(t, args) + ) + if (keepTree) t else EmptyTree } orElse { _ => context.undetparams = savedUndetparams ; EmptyTree } } else EmptyTree - ) + } /* Treats an application which uses named or default arguments. * Also works if names + a vararg used: when names are used, the vararg diff --git a/test/files/neg/t8035-no-adapted-args.check b/test/files/neg/t8035-no-adapted-args.check new file mode 100644 index 000000000000..43637b2c1fc2 --- /dev/null +++ b/test/files/neg/t8035-no-adapted-args.check @@ -0,0 +1,21 @@ +t8035-no-adapted-args.scala:4: warning: No automatic adaptation here: use explicit parentheses. + signature: Test.f[T](x: T): Int + given arguments: 1, 2, 3 + after adaptation: Test.f((1, 2, 3): (Int, Int, Int)) + f(1, 2, 3) + ^ +t8035-no-adapted-args.scala:4: error: too many arguments for method f: (x: (Int, Int, Int))Int + f(1, 2, 3) + ^ +t8035-no-adapted-args.scala:5: warning: No automatic adaptation here: use explicit parentheses. + signature: Test.f[T](x: T): Int + given arguments: + after adaptation: Test.f((): Unit) + f() + ^ +t8035-no-adapted-args.scala:5: error: not enough arguments for method f: (x: Unit)Int. +Unspecified value parameter x. + f() + ^ +two warnings found +two errors found diff --git a/test/files/neg/t8035-no-adapted-args.flags b/test/files/neg/t8035-no-adapted-args.flags new file mode 100644 index 000000000000..b3e8c505e215 --- /dev/null +++ b/test/files/neg/t8035-no-adapted-args.flags @@ -0,0 +1 @@ +-Yno-adapted-args \ No newline at end of file diff --git a/test/files/neg/t8035-no-adapted-args.scala b/test/files/neg/t8035-no-adapted-args.scala new file mode 100644 index 000000000000..82690ebe94a9 --- /dev/null +++ b/test/files/neg/t8035-no-adapted-args.scala @@ -0,0 +1,6 @@ +object Test { + def f[T](x: T) = 0 + + f(1, 2, 3) + f() +} From ec4abf5483e890976ae460252e80a66a95674e61 Mon Sep 17 00:00:00 2001 From: Dominik Gruntz Date: Tue, 15 Jul 2014 11:04:54 +0200 Subject: [PATCH 392/826] Did not know of the fix for SI-8672. Followed the recommendation given by som-snytt. --- src/library/scala/concurrent/Future.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/library/scala/concurrent/Future.scala b/src/library/scala/concurrent/Future.scala index a9b7d79e637c..e93a3284dc33 100644 --- a/src/library/scala/concurrent/Future.scala +++ b/src/library/scala/concurrent/Future.scala @@ -102,7 +102,7 @@ trait Future[+T] extends Awaitable[T] { /* Callbacks */ - /** When this future is completed successfully (i.e. with a value), + /** When this future is completed successfully (i.e., with a value), * apply the provided partial function to the value if the partial function * is defined at that value. * @@ -118,7 +118,7 @@ trait Future[+T] extends Awaitable[T] { case _ => } - /** When this future is completed with a failure (i.e. with a throwable), + /** When this future is completed with a failure (i.e., with a throwable), * apply the provided callback to the throwable. * * $caughtThrowables From 997647eb0dcf1d4028b50f1e30cbef7ead88784a Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 15 Jul 2014 11:45:07 +0200 Subject: [PATCH 393/826] Bump jline version to 2.12 (Re: SI-8535) Move version info where it belongs: versions.properties --- build.xml | 2 -- versions.properties | 1 + 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/build.xml b/build.xml index c407c8d797f4..a89e694ac233 100755 --- a/build.xml +++ b/build.xml @@ -187,8 +187,6 @@ TODO: - - diff --git a/versions.properties b/versions.properties index 1212734d22c3..c334629d2029 100644 --- a/versions.properties +++ b/versions.properties @@ -24,6 +24,7 @@ scala-continuations-library.version.number=1.0.2 scala-swing.version.number=1.0.1 akka-actor.version.number=2.3.3 actors-migration.version.number=1.1.0 +jline.version=2.12 # external modules, used internally (not shipped) partest.version.number=1.0.0 From 5762110d0dc2cb492e34d5595c473aa0f9ca786a Mon Sep 17 00:00:00 2001 From: Philipp Haller Date: Wed, 9 Jul 2014 14:43:12 +0200 Subject: [PATCH 394/826] SI-5919 TypeTags and Exprs should be serializable - Make TypeCreator and TreeCreator extend Serializable. - When replacing a SerializedTypeTag with a TypeTag or WeakTypeTag, do not use scala.reflect.runtime.universe.rootMirror, since it is unlikely to find user classes; instead, create a runtime mirror using the context ClassLoader of the current thread. Use the same logic for SerializedExpr. - Remove writeObject/readObject methods from SerializedTypeTag and SerializedExpr since they are unused. - Add @throws annotation on writeReplace and readResolve methods. - Handle SecurityException if the current thread cannot access the context ClassLoader. - To make type tags of primitive value classes serializable, make PredefTypeCreator a top-level class. Otherwise, it would retain a reference to the enclosing Universe, rendering the TypeCreator non-serializable. Binary compatibility: - Keep nested PredefTypeCreator class to avoid backward binary incompatible change. - Keep `var` modifiers on the class parameters of SerializedTypeTag for backward binary compatibility. - Adds filter rules to forward binary compatibility whitelist: - `TypeCreator`, `PredefTypeCreator`, and `TreeCreator` must now extend from `Serializable`. - Must have new class `scala.reflect.api.PredefTypeCreator` to avoid problematic outer reference. --- bincompat-forward.whitelist.conf | 17 ++++++++ src/reflect/scala/reflect/api/Exprs.scala | 22 +++++----- .../scala/reflect/api/TreeCreator.scala | 6 +-- .../scala/reflect/api/TypeCreator.scala | 2 +- src/reflect/scala/reflect/api/TypeTags.scala | 40 +++++++++++++------ test/files/run/abstypetags_serialize.check | 4 +- test/files/run/exprs_serialize.check | 21 +++++++++- test/files/run/exprs_serialize.scala | 12 +++++- test/files/run/typetags_serialize.check | 5 ++- test/files/run/typetags_serialize.scala | 5 +++ 10 files changed, 99 insertions(+), 35 deletions(-) diff --git a/bincompat-forward.whitelist.conf b/bincompat-forward.whitelist.conf index 30dac79974fd..0b90cf4c8ba4 100644 --- a/bincompat-forward.whitelist.conf +++ b/bincompat-forward.whitelist.conf @@ -254,6 +254,23 @@ filter { { matchName="scala.reflect.runtime.JavaUniverse.PerRunReporting" problemName=MissingMethodProblem + }, + // see SI-5919 + { + matchName="scala.reflect.api.TypeTags$PredefTypeCreator" + problemName=MissingTypesProblem + }, + { + matchName="scala.reflect.api.TreeCreator" + problemName=MissingTypesProblem + }, + { + matchName="scala.reflect.api.TypeCreator" + problemName=MissingTypesProblem + }, + { + matchName="scala.reflect.api.PredefTypeCreator" + problemName=MissingClassProblem } ] } diff --git a/src/reflect/scala/reflect/api/Exprs.scala b/src/reflect/scala/reflect/api/Exprs.scala index 5b6ff2325c9e..6d401b5a798c 100644 --- a/src/reflect/scala/reflect/api/Exprs.scala +++ b/src/reflect/scala/reflect/api/Exprs.scala @@ -9,6 +9,7 @@ package api import scala.reflect.runtime.{universe => ru} import scala.annotation.compileTimeOnly +import java.io.ObjectStreamException /** * EXPERIMENTAL @@ -157,23 +158,22 @@ trait Exprs { self: Universe => |if you want to get a value of the underlying expression, add scala-compiler.jar to the classpath, |import `scala.tools.reflect.Eval` and call `.eval` instead.""".trim.stripMargin) + @throws(classOf[ObjectStreamException]) private def writeReplace(): AnyRef = new SerializedExpr(treec, implicitly[WeakTypeTag[T]].in(ru.rootMirror)) } } private[scala] class SerializedExpr(var treec: TreeCreator, var tag: ru.WeakTypeTag[_]) extends Serializable { - private def writeObject(out: java.io.ObjectOutputStream): Unit = { - out.writeObject(treec) - out.writeObject(tag) - } - - private def readObject(in: java.io.ObjectInputStream): Unit = { - treec = in.readObject().asInstanceOf[TreeCreator] - tag = in.readObject().asInstanceOf[ru.WeakTypeTag[_]] - } + import scala.reflect.runtime.universe.{Expr, runtimeMirror} + @throws(classOf[ObjectStreamException]) private def readResolve(): AnyRef = { - import ru._ - Expr(rootMirror, treec)(tag) + val loader: ClassLoader = try { + Thread.currentThread().getContextClassLoader() + } catch { + case se: SecurityException => null + } + val m = runtimeMirror(loader) + Expr(m, treec)(tag.in(m)) } } diff --git a/src/reflect/scala/reflect/api/TreeCreator.scala b/src/reflect/scala/reflect/api/TreeCreator.scala index 027c84095572..000eaa1aa614 100644 --- a/src/reflect/scala/reflect/api/TreeCreator.scala +++ b/src/reflect/scala/reflect/api/TreeCreator.scala @@ -2,12 +2,12 @@ package scala package reflect package api -/** This is an internal implementation class. +/** A mirror-aware factory for trees. * * This class is used internally by Scala Reflection, and is not recommended for use in client code. * - * @group ReflectionAPI + * @group ReflectionAPI */ -abstract class TreeCreator { +abstract class TreeCreator extends Serializable { def apply[U <: Universe with Singleton](m: scala.reflect.api.Mirror[U]): U # Tree } diff --git a/src/reflect/scala/reflect/api/TypeCreator.scala b/src/reflect/scala/reflect/api/TypeCreator.scala index 37fff90b4390..cbd55b942865 100644 --- a/src/reflect/scala/reflect/api/TypeCreator.scala +++ b/src/reflect/scala/reflect/api/TypeCreator.scala @@ -8,6 +8,6 @@ package api * * @group ReflectionAPI */ -abstract class TypeCreator { +abstract class TypeCreator extends Serializable { def apply[U <: Universe with Singleton](m: scala.reflect.api.Mirror[U]): U # Type } diff --git a/src/reflect/scala/reflect/api/TypeTags.scala b/src/reflect/scala/reflect/api/TypeTags.scala index 1dfc84be6917..1d53453bde1e 100644 --- a/src/reflect/scala/reflect/api/TypeTags.scala +++ b/src/reflect/scala/reflect/api/TypeTags.scala @@ -9,6 +9,7 @@ package api import java.lang.{ Class => jClass } import scala.language.implicitConversions +import java.io.ObjectStreamException /** * A `TypeTag[T]` encapsulates the runtime type representation of some type `T`. @@ -233,6 +234,7 @@ trait TypeTags { self: Universe => val otherMirror1 = otherMirror.asInstanceOf[scala.reflect.api.Mirror[otherMirror.universe.type]] otherMirror.universe.WeakTypeTag[T](otherMirror1, tpec) } + @throws(classOf[ObjectStreamException]) private def writeReplace(): AnyRef = new SerializedTypeTag(tpec, concrete = false) } @@ -293,10 +295,13 @@ trait TypeTags { self: Universe => val otherMirror1 = otherMirror.asInstanceOf[scala.reflect.api.Mirror[otherMirror.universe.type]] otherMirror.universe.TypeTag[T](otherMirror1, tpec) } + @throws(classOf[ObjectStreamException]) private def writeReplace(): AnyRef = new SerializedTypeTag(tpec, concrete = true) } /* @group TypeTags */ + // This class only exists to silence MIMA complaining about a binary incompatibility. + // Only the top-level class (api.PredefTypeCreator) should be used. private class PredefTypeCreator[T](copyIn: Universe => Universe#TypeTag[T]) extends TypeCreator { def apply[U <: Universe with Singleton](m: scala.reflect.api.Mirror[U]): U # Type = { copyIn(m.universe).asInstanceOf[U # TypeTag[T]].tpe @@ -304,8 +309,9 @@ trait TypeTags { self: Universe => } /* @group TypeTags */ - private class PredefTypeTag[T](_tpe: Type, copyIn: Universe => Universe#TypeTag[T]) extends TypeTagImpl[T](rootMirror, new PredefTypeCreator(copyIn)) { + private class PredefTypeTag[T](_tpe: Type, copyIn: Universe => Universe#TypeTag[T]) extends TypeTagImpl[T](rootMirror, new api.PredefTypeCreator(copyIn)) { override lazy val tpe: Type = _tpe + @throws(classOf[ObjectStreamException]) private def writeReplace(): AnyRef = new SerializedTypeTag(tpec, concrete = true) } @@ -341,20 +347,28 @@ trait TypeTags { self: Universe => def symbolOf[T: WeakTypeTag]: TypeSymbol } +// This class should be final, but we can't do that in Scala 2.11.x without breaking +// binary incompatibility. +// Since instances of this class are serialized, this class should have a +// SerialVersionUID annotation. private[scala] class SerializedTypeTag(var tpec: TypeCreator, var concrete: Boolean) extends Serializable { - private def writeObject(out: java.io.ObjectOutputStream): Unit = { - out.writeObject(tpec) - out.writeBoolean(concrete) - } - - private def readObject(in: java.io.ObjectInputStream): Unit = { - tpec = in.readObject().asInstanceOf[TypeCreator] - concrete = in.readBoolean() + import scala.reflect.runtime.universe.{TypeTag, WeakTypeTag, runtimeMirror} + @throws(classOf[ObjectStreamException]) + private def readResolve(): AnyRef = { + val loader: ClassLoader = try { + Thread.currentThread().getContextClassLoader() + } catch { + case se: SecurityException => null + } + val m = runtimeMirror(loader) + if (concrete) TypeTag(m, tpec) + else WeakTypeTag(m, tpec) } +} - private def readResolve(): AnyRef = { - import scala.reflect.runtime.universe._ - if (concrete) TypeTag(rootMirror, tpec) - else WeakTypeTag(rootMirror, tpec) +/* @group TypeTags */ +private class PredefTypeCreator[T](copyIn: Universe => Universe#TypeTag[T]) extends TypeCreator { + def apply[U <: Universe with Singleton](m: scala.reflect.api.Mirror[U]): U # Type = { + copyIn(m.universe).asInstanceOf[U # TypeTag[T]].tpe } } diff --git a/test/files/run/abstypetags_serialize.check b/test/files/run/abstypetags_serialize.check index bddc4523e653..1b5e2ebddf25 100644 --- a/test/files/run/abstypetags_serialize.check +++ b/test/files/run/abstypetags_serialize.check @@ -1,2 +1,2 @@ -java.io.NotSerializableException: Test$$typecreator1$1 -java.io.NotSerializableException: Test$$typecreator2$1 +WeakTypeTag[T] +WeakTypeTag[U[String]] diff --git a/test/files/run/exprs_serialize.check b/test/files/run/exprs_serialize.check index 20ad6c110c80..551823ccdc70 100644 --- a/test/files/run/exprs_serialize.check +++ b/test/files/run/exprs_serialize.check @@ -1,2 +1,19 @@ -java.io.NotSerializableException: Test$$treecreator1$1 -java.io.NotSerializableException: Test$$treecreator2$1 +Expr[Int(2)](2) +Expr[java.lang.String]({ + def foo = "hello"; + foo.$plus("world!") +}) +Expr[Boolean]({ + def foo(x: Int) = { + class Local extends AnyRef { + def () = { + super.(); + () + }; + val f = 2 + }; + val obj = new Local(); + x.$percent(obj.f).$eq$eq(0) + }; + foo(5) +}) diff --git a/test/files/run/exprs_serialize.scala b/test/files/run/exprs_serialize.scala index c4310b0fe1e3..91027803b464 100644 --- a/test/files/run/exprs_serialize.scala +++ b/test/files/run/exprs_serialize.scala @@ -26,4 +26,14 @@ object Test extends App { test(reify(2)) test(reify{def foo = "hello"; foo + "world!"}) -} \ No newline at end of file + test(reify { + def foo(x: Int) = { + class Local { + val f = 2 + } + val obj = new Local + x % obj.f == 0 + } + foo(5) + }) +} diff --git a/test/files/run/typetags_serialize.check b/test/files/run/typetags_serialize.check index f79436ea5d6f..22928a2e94d8 100644 --- a/test/files/run/typetags_serialize.check +++ b/test/files/run/typetags_serialize.check @@ -1,2 +1,3 @@ -java.io.NotSerializableException: scala.reflect.api.TypeTags$PredefTypeCreator -java.io.NotSerializableException: Test$$typecreator1$1 +TypeTag[Int] +TypeTag[String] +TypeTag[Test.C[Double]] diff --git a/test/files/run/typetags_serialize.scala b/test/files/run/typetags_serialize.scala index 3c842e6cc9a7..a7a784523205 100644 --- a/test/files/run/typetags_serialize.scala +++ b/test/files/run/typetags_serialize.scala @@ -4,6 +4,10 @@ import scala.reflect.runtime.{universe => ru} import scala.reflect.runtime.{currentMirror => cm} object Test extends App { + class C[A] { + def m(a: A): Int = 5 + } + def test(tag: TypeTag[_]) = try { val fout = new ByteArrayOutputStream() @@ -26,4 +30,5 @@ object Test extends App { test(implicitly[TypeTag[Int]]) test(implicitly[TypeTag[String]]) + test(implicitly[TypeTag[C[Double]]]) } \ No newline at end of file From f15a289ec5c192ced30970bd9ab23cbf38ead92e Mon Sep 17 00:00:00 2001 From: Philipp Haller Date: Mon, 14 Jul 2014 19:12:47 +0200 Subject: [PATCH 395/826] Add SerialVersionUID to SerializedTypeTag and SerializedExpr The reason for adding the SerialVersionUID annotations is to be able to provide serialization stability throughout the 2.11.x series. And since type tags (and exprs) have not been serializable before, this does not break serialization for existing code. --- src/reflect/scala/reflect/api/Exprs.scala | 1 + src/reflect/scala/reflect/api/TypeTags.scala | 3 +-- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/reflect/scala/reflect/api/Exprs.scala b/src/reflect/scala/reflect/api/Exprs.scala index 6d401b5a798c..3230fdbc67ca 100644 --- a/src/reflect/scala/reflect/api/Exprs.scala +++ b/src/reflect/scala/reflect/api/Exprs.scala @@ -163,6 +163,7 @@ trait Exprs { self: Universe => } } +@SerialVersionUID(1L) private[scala] class SerializedExpr(var treec: TreeCreator, var tag: ru.WeakTypeTag[_]) extends Serializable { import scala.reflect.runtime.universe.{Expr, runtimeMirror} diff --git a/src/reflect/scala/reflect/api/TypeTags.scala b/src/reflect/scala/reflect/api/TypeTags.scala index 1d53453bde1e..7db375ca61f9 100644 --- a/src/reflect/scala/reflect/api/TypeTags.scala +++ b/src/reflect/scala/reflect/api/TypeTags.scala @@ -349,8 +349,7 @@ trait TypeTags { self: Universe => // This class should be final, but we can't do that in Scala 2.11.x without breaking // binary incompatibility. -// Since instances of this class are serialized, this class should have a -// SerialVersionUID annotation. +@SerialVersionUID(1L) private[scala] class SerializedTypeTag(var tpec: TypeCreator, var concrete: Boolean) extends Serializable { import scala.reflect.runtime.universe.{TypeTag, WeakTypeTag, runtimeMirror} @throws(classOf[ObjectStreamException]) From 68b16a0992877b4ebbb7c967804edbb72c05ceb5 Mon Sep 17 00:00:00 2001 From: Masato Sogame Date: Mon, 14 Jul 2014 20:20:51 +0900 Subject: [PATCH 396/826] Update javadoc tag to new scaladoc tags. --- .../scala/tools/nsc/ast/DocComments.scala | 9 +++++++- .../scala/tools/nsc/doc/ScaladocGlobal.scala | 1 + .../nsc/doc/base/CommentFactoryBase.scala | 22 +++++++++---------- 3 files changed, 20 insertions(+), 12 deletions(-) diff --git a/src/compiler/scala/tools/nsc/ast/DocComments.scala b/src/compiler/scala/tools/nsc/ast/DocComments.scala index 6d9b41ec45b7..02a199f7ac47 100755 --- a/src/compiler/scala/tools/nsc/ast/DocComments.scala +++ b/src/compiler/scala/tools/nsc/ast/DocComments.scala @@ -59,14 +59,21 @@ trait DocComments { self: Global => comment.defineVariables(sym) } + + def replaceInheritDocToInheritdoc(docStr: String):String = { + docStr.replaceAll("""\{@inheritDoc\p{Zs}*\}""", "@inheritdoc") + } + /** The raw doc comment of symbol `sym`, minus usecase and define sections, augmented by * missing sections of an inherited doc comment. * If a symbol does not have a doc comment but some overridden version of it does, * the doc comment of the overridden version is copied instead. */ def cookedDocComment(sym: Symbol, docStr: String = ""): String = cookedDocComments.getOrElseUpdate(sym, { - val ownComment = if (docStr.length == 0) docComments get sym map (_.template) getOrElse "" + var ownComment = if (docStr.length == 0) docComments get sym map (_.template) getOrElse "" else DocComment(docStr).template + ownComment = replaceInheritDocToInheritdoc(ownComment) + superComment(sym) match { case None => if (ownComment.indexOf("@inheritdoc") != -1) diff --git a/src/scaladoc/scala/tools/nsc/doc/ScaladocGlobal.scala b/src/scaladoc/scala/tools/nsc/doc/ScaladocGlobal.scala index 2ea3a0eb7ca1..4b40d25c1780 100644 --- a/src/scaladoc/scala/tools/nsc/doc/ScaladocGlobal.scala +++ b/src/scaladoc/scala/tools/nsc/doc/ScaladocGlobal.scala @@ -11,6 +11,7 @@ import reporters.Reporter import typechecker.Analyzer import scala.reflect.internal.util.{ BatchSourceFile, RangePosition } + trait ScaladocGlobalTrait extends Global { outer => diff --git a/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala b/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala index 19cc27b40b0d..d5e2f9a2c4d5 100755 --- a/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala +++ b/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala @@ -131,18 +131,19 @@ trait CommentFactoryBase { this: MemberLookupBase => /** Javadoc tags that should be replaced by something useful, such as wiki * syntax, or that should be dropped. */ private val JavadocTags = - new Regex("""\{\@(code|docRoot|inheritDoc|link|linkplain|literal|value)([^}]*)\}""") + new Regex("""\{\@(code|docRoot|linkplain|link|literal|value)\p{Zs}*([^}]*)\}""") /** Maps a javadoc tag to a useful wiki replacement, or an empty string if it cannot be salvaged. */ - private def javadocReplacement(mtch: Regex.Match): String = mtch.group(1) match { - case "code" => "`" + mtch.group(2) + "`" - case "docRoot" => "" - case "inheritDoc" => "" - case "link" => "`" + mtch.group(2) + "`" - case "linkplain" => "`" + mtch.group(2) + "`" - case "literal" => mtch.group(2) - case "value" => "`" + mtch.group(2) + "`" - case _ => "" + private def javadocReplacement(mtch: Regex.Match): String = { + mtch.group(1) match { + case "code" => "" + mtch.group(2) + "" + case "docRoot" => "" + case "link" => "`[[" + mtch.group(2) + "]]`" + case "linkplain" => "[[" + mtch.group(2) + "]]" + case "literal" => "`" + mtch.group(2) + "`" + case "value" => "`" + mtch.group(2) + "`" + case _ => "" + } } /** Safe HTML tags that can be kept. */ @@ -680,7 +681,6 @@ trait CommentFactoryBase { this: MemberLookupBase => jump("[[") val parens = 2 + repeatJump('[') val stop = "]" * parens - //println("link with " + parens + " matching parens") val target = readUntil { check(stop) || check(" ") } val title = if (!check(stop)) Some({ From ec46a1fba7395714e65e0f6644b7ad429c985ec7 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Tue, 15 Jul 2014 19:05:52 +0200 Subject: [PATCH 397/826] SI-8557 make scaladoc normalize paths of external jars. Scaladoc compares (string representations of) the paths from -doc-external-doc and the paths form `sym.underlyingSource`. We now normalize on both ends before comparing them. --- .../scala/tools/nsc/doc/Settings.scala | 2 +- .../tools/nsc/doc/model/MemberLookup.scala | 2 +- test/scaladoc/run/t8557.check | 1 + test/scaladoc/run/t8557.scala | 32 +++++++++++++++++++ 4 files changed, 35 insertions(+), 2 deletions(-) create mode 100644 test/scaladoc/run/t8557.check create mode 100644 test/scaladoc/run/t8557.scala diff --git a/src/scaladoc/scala/tools/nsc/doc/Settings.scala b/src/scaladoc/scala/tools/nsc/doc/Settings.scala index 67529f417845..a8e1dee4a048 100644 --- a/src/scaladoc/scala/tools/nsc/doc/Settings.scala +++ b/src/scaladoc/scala/tools/nsc/doc/Settings.scala @@ -249,7 +249,7 @@ class Settings(error: String => Unit, val printMsg: String => Unit = println(_)) val idx = s.indexOf("#") if (idx > 0) { val (first, last) = s.splitAt(idx) - Some(new File(first).getAbsolutePath -> appendIndex(last.substring(1))) + Some(new File(first).getCanonicalPath -> appendIndex(last.substring(1))) } else { error(s"Illegal -doc-external-doc option; expected a pair with '#' separator, found: '$s'") None diff --git a/src/scaladoc/scala/tools/nsc/doc/model/MemberLookup.scala b/src/scaladoc/scala/tools/nsc/doc/model/MemberLookup.scala index 339129bdbcfc..64eb1adbea24 100644 --- a/src/scaladoc/scala/tools/nsc/doc/model/MemberLookup.scala +++ b/src/scaladoc/scala/tools/nsc/doc/model/MemberLookup.scala @@ -45,7 +45,7 @@ trait MemberLookup extends base.MemberLookupBase { sym.info.member(newTermName("package")) else sym Option(sym1.associatedFile) flatMap (_.underlyingSource) flatMap { src => - val path = src.path + val path = src.canonicalPath settings.extUrlMapping get path map { url => LinkToExternal(name, url + "#" + name) } diff --git a/test/scaladoc/run/t8557.check b/test/scaladoc/run/t8557.check new file mode 100644 index 000000000000..619c56180bb9 --- /dev/null +++ b/test/scaladoc/run/t8557.check @@ -0,0 +1 @@ +Done. diff --git a/test/scaladoc/run/t8557.scala b/test/scaladoc/run/t8557.scala new file mode 100644 index 000000000000..451f004d7d43 --- /dev/null +++ b/test/scaladoc/run/t8557.scala @@ -0,0 +1,32 @@ +import scala.tools.nsc.doc.base._ +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocModelTest + +object Test extends ScaladocModelTest { + + override def code = """ + package scala.test.scaladoc.T8857 + + /** + * A link: + * + * [[scala.Option$ object Option]]. + */ + class A + """ + + // a non-canonical path to scala-library.jar should still work + // this is a bit fragile (depends on the current directory being the root of the repo ; + // ant & partest seem to do that properly) + def scaladocSettings = "-doc-external-doc build/pack/bin/../lib/scala-library.jar#http://www.scala-lang.org/api/current/" + + def testModel(rootPackage: Package) = { + // get the quick access implicit defs in scope (_package(s), _class(es), _trait(s), object(s) _method(s), _value(s)) + import access._ + + val a = rootPackage._package("scala")._package("test")._package("scaladoc")._package("T8857")._class("A") + + val links = countLinks(a.comment.get, _.link.isInstanceOf[LinkToExternal]) + assert(links == 1, links + " == 1 (the links to external in class A)") + } +} From f81ec8d1f6481ddacfb27e743c6c58961e765f0e Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Wed, 16 Jul 2014 11:01:31 -0700 Subject: [PATCH 398/826] SI-8525 Clarify usage of -Xlint:_,flag Also clarify usage of -Xlint flag. Align more with javac -Xlint:all,-flag,flag where once a flag is explicitly enabled it cannot be disabled, but where the wildcard is a backstop only. (There is no all option yet here.) -Xlint and -Xlint:_ just set a flag which is consulted by any unset lint warning. Xlint warnings consult the state of Xlint when they are unset. Individual -Ywarn-ings do not. Other warnings are explicitly set to false. They can only be enabled programmatically. Some tests are corrected. Also, option order is no longer significant, see the unit test. --- .../tools/nsc/settings/MutableSettings.scala | 9 +- .../scala/tools/nsc/settings/Warnings.scala | 120 +++++++++--------- test/files/neg/t8610-arg.check | 14 +- test/files/neg/t8610-arg.flags | 2 +- test/files/run/t8610.check | 6 - .../tools/nsc/settings/SettingsTest.scala | 24 ++-- 6 files changed, 77 insertions(+), 98 deletions(-) diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala index dc49e8b822a2..0dd4ae0b3b04 100644 --- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala @@ -567,13 +567,12 @@ class MutableSettings(val errorFn: String => Unit) def badChoice(s: String, n: String) = errorFn(s"'$s' is not a valid choice for '$name'") def choosing = choices.nonEmpty def isChoice(s: String) = (s == "_") || (choices contains (s stripPrefix "-")) - def wildcards = choices // filter (!_.isSetByUser) override protected def tts(args: List[String], halting: Boolean) = { - val total = collection.mutable.ListBuffer.empty[String] ++ value + val added = collection.mutable.ListBuffer.empty[String] def tryArg(arg: String) = arg match { - case "_" if choosing => wildcards foreach (total += _) - case s if !choosing || isChoice(s) => total += s + case "_" if choosing => default() + case s if !choosing || isChoice(s) => added += s case s => badChoice(s, name) } def stoppingAt(arg: String) = (arg startsWith "-") || (choosing && !isChoice(arg)) @@ -584,7 +583,7 @@ class MutableSettings(val errorFn: String => Unit) } val rest = loop(args) if (rest.size == args.size) default() // if no arg consumed, trigger default action - else value = total.toList // update once + else value = added.toList // update all new settings at once Some(rest) } } diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala index 3ff2369f860d..0b9ad8004196 100644 --- a/src/compiler/scala/tools/nsc/settings/Warnings.scala +++ b/src/compiler/scala/tools/nsc/settings/Warnings.scala @@ -17,12 +17,15 @@ trait Warnings { // Warning semantics. val fatalWarnings = BooleanSetting("-Xfatal-warnings", "Fail the compilation if there are any warnings.") - // These warnings are all so noisy as to be useless in their + // These additional warnings are all so noisy as to be useless in their // present form, but have the potential to offer useful info. protected def allWarnings = lintWarnings ++ List( warnDeadCode, warnValueDiscard, - warnNumericWiden + warnNumericWiden, + warnUnused, // SI-7712, SI-7707 warnUnused not quite ready for prime-time + warnUnusedImport, // currently considered too noisy for general use + warnValueOverrides // currently turned off as experimental ) // These warnings should be pretty quiet unless you're doing // something inadvisable. @@ -32,9 +35,6 @@ trait Warnings { warnNullaryUnit, warnAdaptedArgs, warnInferAny, - // warnUnused SI-7712, SI-7707 warnUnused not quite ready for prime-time - // warnUnusedImport currently considered too noisy for general use - // warnValueOverrides warnMissingInterpolator, warnDocDetached, warnPrivateShadow, @@ -46,22 +46,26 @@ trait Warnings { warnUnsoundMatch ) - private lazy val warnSelectNullable = BooleanSetting("-Xcheck-null", "This option is obsolete and does nothing.") + // Individual warnings. They can be set with -Ywarn. + private def nonlintflag(name: String, text: String): BooleanSetting = BooleanSetting(name, text) - // Individual warnings. - val warnDeadCode = BooleanSetting("-Ywarn-dead-code", + val warnDeadCode = nonlintflag("-Ywarn-dead-code", "Warn when dead code is identified.") - val warnValueDiscard = BooleanSetting("-Ywarn-value-discard", + val warnValueDiscard = nonlintflag("-Ywarn-value-discard", "Warn when non-Unit expression results are unused.") - val warnNumericWiden = BooleanSetting("-Ywarn-numeric-widen", + val warnNumericWiden = nonlintflag("-Ywarn-numeric-widen", "Warn when numerics are widened.") - val warnUnused = BooleanSetting("-Ywarn-unused", + val warnUnused = nonlintflag("-Ywarn-unused", "Warn when local and private vals, vars, defs, and types are are unused") - val warnUnusedImport = BooleanSetting("-Ywarn-unused-import", + val warnUnusedImport = nonlintflag("-Ywarn-unused-import", "Warn when imports are unused") - // Lint warnings that are not -Y, created with new instead of autoregistering factory method - private def lintflag(name: String, text: String) = new BooleanSetting(name, text) + // Lint warnings that have no -Y avatar, created with new instead of the autoregistering factory method. + // They evaluate true if set to true or else are unset but -Xlint is true + private def lintflag(name: String, text: String): BooleanSetting = + new BooleanSetting(name, text) { + override def value = if (isSetByUser) super.value else xlint + } val warnAdaptedArgs = lintflag("adapted-args", "Warn if an argument list is modified to match the receiver.") @@ -92,59 +96,59 @@ trait Warnings { val warnUnsoundMatch = lintflag("unsound-match", "Pattern match may not be typesafe") - // Lint warnings that are not enabled yet - val warnValueOverrides = lintflag("value-overrides", "Generated value class method overrides an implementation") + // Experimental lint warnings that are turned off, but which could be turned on programmatically. + // These warnings are said to blind those who dare enable them. + // They are not activated by -Xlint and can't be enabled on the command line. + val warnValueOverrides = { + val flag = lintflag("value-overrides", "Generated value class method overrides an implementation") + flag.value = false + flag + } - // Warning groups. - val lint = { - // Boolean setting for testing if lint is on; not "added" to option processing - val xlint = lintflag("-Xlint", "Enable recommended additional warnings.") - val yprefix = "-Ywarn-" - def lintables = (lintWarnings map (_.name stripPrefix yprefix)).sorted - def isAnon(b: BooleanSetting) = !(b.name startsWith "-") - def setPolitely(b: BooleanSetting, v: Boolean) = if (!b.isSetByUser) b.value = v - def set(w: String, v: Boolean) = lintWarnings find (s => (s.name stripPrefix yprefix) == w) foreach (b => setPolitely(b, v)) - val Neg = "-" - def propagate(ss: List[String]): Unit = ss match { - case w :: rest => if (w startsWith Neg) set(w stripPrefix Neg, false) else set(w, true) ; propagate(rest) - case Nil => () - } - // enable lint and the group, honoring previous -Y settings - def enableAll(): Unit = { - xlint.value = true - for (s <- lintWarnings) setPolitely(s, true) + // The Xlint warning group. + private val xlint = new BooleanSetting("-Zunused", "True if -Xlint or -Xlint:_") + // On -Xlint or -Xlint:_, set xlint, otherwise set the lint warning unless already set true + val lint = + MultiChoiceSetting( + name = "-Xlint", + helpArg = "warning", + descr = "Enable recommended additional warnings", + choices = (lintWarnings map (_.name)).sorted, + default = () => xlint.value = true + ) withPostSetHook { x => + val Neg = "-" + def setPolitely(b: BooleanSetting, v: Boolean) = if (!b.isSetByUser || !b) b.value = v + def set(w: String, v: Boolean) = lintWarnings find (_.name == w) foreach (setPolitely(_, v)) + def propagate(ss: List[String]): Unit = ss match { + case w :: rest => if (w startsWith Neg) set(w stripPrefix Neg, false) else set(w, true) ; propagate(rest) + case Nil => () + } + propagate(x.value) } - // The command option - MultiChoiceSetting("-Xlint", "warning", "Enable recommended additional warnings", choices = lintables, default = enableAll) withPostSetHook { x => - propagate(x.value) // enabling the selections (on each append to value) - xlint.value = true // only enables lint, not the group - for (b <- lintWarnings if isAnon(b) && !b.isSetByUser) b.value = true // init anonymous settings (but not if disabled) - } - xlint - } // Lint warnings that are currently -Y, but deprecated in that usage - // Alas, the -Yarg must have a doppelgaenger that is not deprecated - @deprecated("Use the Xlint flag", since="2.11.2") + @deprecated("Use warnAdaptedArgs", since="2.11.2") val YwarnAdaptedArgs = BooleanSetting("-Ywarn-adapted-args", - "Warn if an argument list is modified to match the receiver.") withDeprecationMessage - "Enable -Xlint:adapted-args" enabling List(warnAdaptedArgs) - @deprecated("Use the Xlint flag", since="2.11.2") + "Warn if an argument list is modified to match the receiver.") enabling List(warnAdaptedArgs) + //withDeprecationMessage "Enable -Xlint:adapted-args" + @deprecated("Use warnNullaryUnit", since="2.11.2") val YwarnNullaryUnit = BooleanSetting("-Ywarn-nullary-unit", - "Warn when nullary methods return Unit.") withDeprecationMessage - "Enable -Xlint:nullary-unit" enabling List(warnNullaryUnit) - @deprecated("Use the Xlint flag", since="2.11.2") + "Warn when nullary methods return Unit.") enabling List(warnNullaryUnit) + //withDeprecationMessage "Enable -Xlint:nullary-unit" + @deprecated("Use warnInaccessible", since="2.11.2") val YwarnInaccessible = BooleanSetting("-Ywarn-inaccessible", - "Warn about inaccessible types in method signatures.") withDeprecationMessage - "Enable -Xlint:inaccessible" enabling List(warnInaccessible) - @deprecated("Use the Xlint flag", since="2.11.2") + "Warn about inaccessible types in method signatures.") enabling List(warnInaccessible) + //withDeprecationMessage "Enable -Xlint:inaccessible" + @deprecated("Use warnNullaryOverride", since="2.11.2") val YwarnNullaryOverride = BooleanSetting("-Ywarn-nullary-override", - "Warn when non-nullary `def f()' overrides nullary `def f'.") withDeprecationMessage - "Enable -Xlint:nullary-override" enabling List(warnNullaryOverride) - @deprecated("Use the Xlint flag", since="2.11.2") + "Warn when non-nullary `def f()' overrides nullary `def f'.") enabling List(warnNullaryOverride) + //withDeprecationMessage "Enable -Xlint:nullary-override" + @deprecated("Use warnInferAny", since="2.11.2") val YwarnInferAny = BooleanSetting("-Ywarn-infer-any", - "Warn when a type argument is inferred to be `Any`.") withDeprecationMessage - "Enable -Xlint:infer-any" enabling List(warnInferAny) + "Warn when a type argument is inferred to be `Any`.") enabling List(warnInferAny) + //withDeprecationMessage "Enable -Xlint:infer-any" + + private lazy val warnSelectNullable = BooleanSetting("-Xcheck-null", "This option is obsolete and does nothing.") // Backward compatibility. @deprecated("Use fatalWarnings", "2.11.0") def Xwarnfatal = fatalWarnings // used by sbt diff --git a/test/files/neg/t8610-arg.check b/test/files/neg/t8610-arg.check index ea2805508dbd..d6fe2071191f 100644 --- a/test/files/neg/t8610-arg.check +++ b/test/files/neg/t8610-arg.check @@ -1,18 +1,6 @@ -t8610-arg.scala:5: warning: possible missing interpolator: detected interpolated identifier `$name` - def x = "Hi, $name" // missing interp - ^ -t8610-arg.scala:7: warning: Adapting argument list by creating a 2-tuple: this may not be what you want. - signature: X.f(p: (Int, Int)): Int - given arguments: 3, 4 - after adaptation: X.f((3, 4): (Int, Int)) - def g = f(3, 4) // adapted - ^ -t8610-arg.scala:9: warning: private[this] value name in class X shadows mutable name inherited from class Named. Changes to name will not be visible within class X - you may want to give them distinct names. - override def toString = name // shadowing mutable var name - ^ t8610-arg.scala:8: warning: side-effecting nullary methods are discouraged: suggest defining as `def u()` instead def u: Unit = () // unitarian universalist ^ error: No warnings can be incurred under -Xfatal-warnings. -four warnings found +one warning found one error found diff --git a/test/files/neg/t8610-arg.flags b/test/files/neg/t8610-arg.flags index f8867a7b4e69..f331ba938345 100644 --- a/test/files/neg/t8610-arg.flags +++ b/test/files/neg/t8610-arg.flags @@ -1 +1 @@ --Xfatal-warnings -Xlint warn-nullary-unit +-Xfatal-warnings -Xlint nullary-unit diff --git a/test/files/run/t8610.check b/test/files/run/t8610.check index fde82d5109dc..b3ab7a9cefcf 100644 --- a/test/files/run/t8610.check +++ b/test/files/run/t8610.check @@ -1,13 +1,7 @@ -t8610.scala:4: warning: possible missing interpolator: detected interpolated identifier `$name` - def x = "Hi, $name" // missing interp - ^ t8610.scala:6: warning: Adapting argument list by creating a 2-tuple: this may not be what you want. signature: X.f(p: (Int, Int)): Int given arguments: 3, 4 after adaptation: X.f((3, 4): (Int, Int)) def g = f(3, 4) // adapted ^ -t8610.scala:7: warning: side-effecting nullary methods are discouraged: suggest defining as `def u()` instead - def u: Unit = () // unitarian universalist - ^ Hi, $name diff --git a/test/junit/scala/tools/nsc/settings/SettingsTest.scala b/test/junit/scala/tools/nsc/settings/SettingsTest.scala index 9203054d9a15..960d7f8ac1dc 100644 --- a/test/junit/scala/tools/nsc/settings/SettingsTest.scala +++ b/test/junit/scala/tools/nsc/settings/SettingsTest.scala @@ -38,29 +38,23 @@ class SettingsTest { assertFalse(check("-Yinline:false", "-optimise").value) } - @Test def userSettingsHavePrecedenceOverLint() { - def check(args: String*): MutableSettings#BooleanSetting = { - val s = new MutableSettings(msg => throw new IllegalArgumentException(msg)) - val (ok, residual) = s.processArguments(args.toList, processAll = true) - assert(residual.isEmpty) - s.warnAdaptedArgs // among Xlint - } - assertTrue(check("-Xlint").value) - assertFalse(check("-Xlint", "-Ywarn-adapted-args:false").value) - assertFalse(check("-Ywarn-adapted-args:false", "-Xlint").value) - } - - def check(args: String*)(b: MutableSettings => MutableSettings#BooleanSetting): MutableSettings#BooleanSetting = { + // for the given args, select the desired setting + private def check(args: String*)(b: MutableSettings => MutableSettings#BooleanSetting): MutableSettings#BooleanSetting = { val s = new MutableSettings(msg => throw new IllegalArgumentException(msg)) val (ok, residual) = s.processArguments(args.toList, processAll = true) assert(residual.isEmpty) b(s) } + @Test def userSettingsHavePrecedenceOverLint() { + assertTrue(check("-Xlint")(_.warnAdaptedArgs)) + assertFalse(check("-Xlint", "-Ywarn-adapted-args:false")(_.warnAdaptedArgs)) + assertFalse(check("-Ywarn-adapted-args:false", "-Xlint")(_.warnAdaptedArgs)) + } + @Test def anonymousLintersCanBeNamed() { assertTrue(check("-Xlint")(_.warnMissingInterpolator)) // among Xlint assertFalse(check("-Xlint:-missing-interpolator")(_.warnMissingInterpolator)) assertFalse(check("-Xlint:-missing-interpolator", "-Xlint")(_.warnMissingInterpolator)) - // two lint settings are first come etc; unlike -Y - assertTrue(check("-Xlint", "-Xlint:-missing-interpolator")(_.warnMissingInterpolator)) + assertFalse(check("-Xlint", "-Xlint:-missing-interpolator")(_.warnMissingInterpolator)) } } From 41507ba71b7a8a5fbd5dffb4378a963ecd08be2a Mon Sep 17 00:00:00 2001 From: mpociecha Date: Tue, 15 Jul 2014 14:38:50 +0200 Subject: [PATCH 399/826] Remove invalidation from Global.scala The invalidation has been introduced in these commits: https://github.com/scala/scala/commit/167309afd10f9b65b35e6874a30ea6340a1ddc44 https://github.com/scala/scala/commit/ace051ff0abe112b767c3912f846eb4d50e52cf5 https://github.com/scala/scala/commit/e156d4a7cf4afdab91b7c281a0e8ae6e4743cc4a It's safe to remove this functionality. It was added originally to support an experiment with resident compilation. The experiment was performed in sbt and dropped in https://github.com/sbt/sbt/commit/6def08e029e474dc35af04b7403a2aeaddd0dec6 Since then Scala team concluded to not work on resident compilation so it's safe to delete unused code. --- src/compiler/scala/tools/nsc/Global.scala | 237 ------------------ .../tools/nsc/settings/ScalaSettings.scala | 1 - 2 files changed, 238 deletions(-) diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 572e579aca2e..5bf0d8d9f753 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -831,198 +831,11 @@ class Global(var currentSettings: Settings, var reporter: Reporter) } reverse } - // ------------ Invalidations --------------------------------- - - /** Is given package class a system package class that cannot be invalidated? - */ - private def isSystemPackageClass(pkg: Symbol) = - pkg == RootClass || - pkg == definitions.ScalaPackageClass || { - val pkgname = pkg.fullName - (pkgname startsWith "scala.") && !(pkgname startsWith "scala.tools") - } - - /** Invalidates packages that contain classes defined in a classpath entry, and - * rescans that entry. - * @param paths Fully qualified names that refer to directories or jar files that are - * a entries on the classpath. - * First, causes the classpath entry referred to by `path` to be rescanned, so that - * any new files or deleted files or changes in subpackages are picked up. - * Second, invalidates any packages for which one of the following considitions is met: - - * - the classpath entry contained during the last compilation run classfiles - * that represent a member in the package - * - the classpath entry now contains classfiles - * that represent a member in the package - * - the set of subpackages has changed. - * - * The invalidated packages are reset in their entirety; all member classes and member packages - * are re-accessed using the new classpath. - * Not invalidated are system packages that the compiler needs to access as parts - * of standard definitions. The criterion what is a system package is currently: - * any package rooted in "scala", with the exception of packages rooted in "scala.tools". - * This can be refined later. - * @return A pair consisting of - * - a list of invalidated packages - * - a list of of packages that should have been invalidated but were not because - * they are system packages. - */ - def invalidateClassPathEntries(paths: String*): (List[ClassSymbol], List[ClassSymbol]) = { - val invalidated, failed = new mutable.ListBuffer[ClassSymbol] - classPath match { - case cp: MergedClassPath[_] => - def assoc(path: String): List[(PlatformClassPath, PlatformClassPath)] = { - val dir = AbstractFile getDirectory path - val canonical = dir.canonicalPath - def matchesCanonical(e: ClassPath[_]) = e.origin match { - case Some(opath) => - (AbstractFile getDirectory opath).canonicalPath == canonical - case None => - false - } - cp.entries find matchesCanonical match { - case Some(oldEntry) => - List(oldEntry -> cp.context.newClassPath(dir)) - case None => - println(s"canonical = $canonical, origins = ${cp.entries map (_.origin)}") - error(s"cannot invalidate: no entry named $path in classpath $classPath") - List() - } - } - val subst = Map(paths flatMap assoc: _*) - if (subst.nonEmpty) { - platform updateClassPath subst - informProgress(s"classpath updated on entries [${subst.keys mkString ","}]") - def mkClassPath(elems: Iterable[PlatformClassPath]): PlatformClassPath = - if (elems.size == 1) elems.head - else new MergedClassPath(elems, classPath.context) - val oldEntries = mkClassPath(subst.keys) - val newEntries = mkClassPath(subst.values) - reSync(RootClass, Some(classPath), Some(oldEntries), Some(newEntries), invalidated, failed) - } - } - def show(msg: String, syms: scala.collection.Traversable[Symbol]) = - if (syms.nonEmpty) - informProgress(s"$msg: ${syms map (_.fullName) mkString ","}") - show("invalidated packages", invalidated) - show("could not invalidate system packages", failed) - (invalidated.toList, failed.toList) - } - - /** Re-syncs symbol table with classpath - * @param root The root symbol to be resynced (a package class) - * @param allEntries Optionally, the corresponding package in the complete current classPath - * @param oldEntries Optionally, the corresponding package in the old classPath entries - * @param newEntries Optionally, the corresponding package in the new classPath entries - * @param invalidated A listbuffer collecting the invalidated package classes - * @param failed A listbuffer collecting system package classes which could not be invalidated - * The resyncing strategy is determined by the absence or presence of classes and packages. - * If either oldEntries or newEntries contains classes, root is invalidated, provided a corresponding package - * exists in allEntries, or otherwise is removed. - * Otherwise, the action is determined by the following matrix, with columns: - * - * old new all sym action - * + + + + recurse into all child packages of old ++ new - * + - + + invalidate root - * + - - + remove root from its scope - * - + + + invalidate root - * - + + - create and enter root - * - - * * no action - * - * Here, old, new, all mean classpaths and sym means symboltable. + is presence of an - * entry in its column, - is absence, * is don't care. - * - * Note that new <= all and old <= sym, so the matrix above covers all possibilities. - */ - private def reSync(root: ClassSymbol, - allEntries: OptClassPath, oldEntries: OptClassPath, newEntries: OptClassPath, - invalidated: mutable.ListBuffer[ClassSymbol], failed: mutable.ListBuffer[ClassSymbol]) { - ifDebug(informProgress(s"syncing $root, $oldEntries -> $newEntries")) - - val getName: ClassPath[AbstractFile] => String = (_.name) - def hasClasses(cp: OptClassPath) = cp.isDefined && cp.get.classes.nonEmpty - def invalidateOrRemove(root: ClassSymbol) = { - allEntries match { - case Some(cp) => root setInfo new loaders.PackageLoader(cp) - case None => root.owner.info.decls unlink root.sourceModule - } - invalidated += root - } - def packageNames(cp: PlatformClassPath): Set[String] = cp.packages.toSet map getName - def subPackage(cp: PlatformClassPath, name: String): OptClassPath = - cp.packages find (cp1 => getName(cp1) == name) - - val classesFound = hasClasses(oldEntries) || hasClasses(newEntries) - if (classesFound && !isSystemPackageClass(root)) { - invalidateOrRemove(root) - } else { - if (classesFound) { - if (root.isRoot) invalidateOrRemove(EmptyPackageClass) - else failed += root - } - (oldEntries, newEntries) match { - case (Some(oldcp) , Some(newcp)) => - for (pstr <- packageNames(oldcp) ++ packageNames(newcp)) { - val pname = newTermName(pstr) - val pkg = (root.info decl pname) orElse { - // package was created by external agent, create symbol to track it - assert(!subPackage(oldcp, pstr).isDefined) - loaders.enterPackage(root, pstr, new loaders.PackageLoader(allEntries.get)) - } - reSync( - pkg.moduleClass.asInstanceOf[ClassSymbol], - subPackage(allEntries.get, pstr), subPackage(oldcp, pstr), subPackage(newcp, pstr), - invalidated, failed) - } - case (Some(oldcp), None) => - invalidateOrRemove(root) - case (None, Some(newcp)) => - invalidateOrRemove(root) - case (None, None) => - } - } - } - - /** Invalidate contents of setting -Yinvalidate */ - def doInvalidation() = settings.Yinvalidate.value match { - case "" => - case entry => invalidateClassPathEntries(entry) - } - // ----------- Runs --------------------------------------- private var curRun: Run = null private var curRunId = 0 - /** A hook that lets subclasses of `Global` define whether a package or class should be kept loaded for the - * next compiler run. If the parameter `sym` is a class or object, and `clearOnNextRun(sym)` returns `true`, - * then the symbol is unloaded and reset to its state before the last compiler run. If the parameter `sym` is - * a package, and clearOnNextRun(sym)` returns `true`, the package is recursively searched for - * classes to drop. - * - * Example: Let's say I want a compiler that drops all classes corresponding to the current project - * between runs. Then `keepForNextRun` of a toplevel class or object should return `true` if the - * class or object does not form part of the current project, `false` otherwise. For a package, - * clearOnNextRun should return `true` if no class in that package forms part of the current project, - * `false` otherwise. - * - * @param sym A class symbol, object symbol, package, or package class. - */ - @deprecated("use invalidateClassPathEntries instead", "2.10.0") - def clearOnNextRun(sym: Symbol) = false - /* To try out clearOnNext run on the scala.tools.nsc project itself - * replace `false` above with the following code - - settings.Xexperimental.value && { sym.isRoot || { - sym.fullName match { - case "scala" | "scala.tools" | "scala.tools.nsc" => true - case _ => sym.owner.fullName.startsWith("scala.tools.nsc") - } - }} - - * Then, fsc -Xexperimental clears the nsc project between successive runs of `fsc`. - */ - object typeDeconstruct extends { val global: Global.this.type = Global.this } with typechecker.StructuredTypeStrings @@ -1292,47 +1105,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter) first } - /** Reset all classes contained in current project, as determined by - * the clearOnNextRun hook - */ - @deprecated("use invalidateClassPathEntries instead", "2.10.0") - def resetProjectClasses(root: Symbol): Unit = try { - def unlink(sym: Symbol) = - if (sym != NoSymbol) root.info.decls.unlink(sym) - if (settings.verbose) inform("[reset] recursing in "+root) - val toReload = mutable.Set[String]() - for (sym <- root.info.decls) { - if (sym.isInitialized && clearOnNextRun(sym)) - if (sym.hasPackageFlag) { - resetProjectClasses(sym.moduleClass) - openPackageModule(sym.moduleClass) - } else { - unlink(sym) - unlink(root.info.decls.lookup( - if (sym.isTerm) sym.name.toTypeName else sym.name.toTermName)) - toReload += sym.fullName - // note: toReload could be set twice with the same name - // but reinit must happen only once per name. That's why - // the following classPath.findClass { ... } code cannot be moved here. - } - } - for (fullname <- toReload) - classPath.findClass(fullname) match { - case Some(classRep) => - if (settings.verbose) inform("[reset] reinit "+fullname) - loaders.initializeFromClassPath(root, classRep) - case _ => - } - } catch { - case ex: Throwable => - // this handler should not be nessasary, but it seems that `fsc` - // eats exceptions if they appear here. Need to find out the cause for - // this and fix it. - inform("[reset] exception happened: "+ex) - ex.printStackTrace() - throw ex - } - // --------------- Miscellania ------------------------------- /** Progress tracking. Measured in "progress units" which are 1 per @@ -1542,8 +1314,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter) compileUnitsInternal(units, fromPhase) private def compileUnitsInternal(units: List[CompilationUnit], fromPhase: Phase) { - doInvalidation() - units foreach addUnit val startTime = currentTime @@ -1619,13 +1389,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter) // Clear any sets or maps created via perRunCaches. perRunCaches.clearAll() - - // Reset project - if (!stopPhase("namer")) { - enteringPhase(namerPhase) { - resetProjectClasses(RootClass) - } - } } /** Compile list of abstract files. */ diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala index d22dcacad67e..87cd05bdb4af 100644 --- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala @@ -185,7 +185,6 @@ trait ScalaSettings extends AbsScalaSettings val YmethodInfer = BooleanSetting ("-Yinfer-argument-types", "Infer types for arguments of overriden methods.") val etaExpandKeepsStar = BooleanSetting ("-Yeta-expand-keeps-star", "Eta-expand varargs methods to T* rather than Seq[T]. This is a temporary option to ease transition.").withDeprecationMessage(removalIn212) val inferByName = BooleanSetting ("-Yinfer-by-name", "Allow inference of by-name types. This is a temporary option to ease transition. See SI-7899.").withDeprecationMessage(removalIn212) - val Yinvalidate = StringSetting ("-Yinvalidate", "classpath-entry", "Invalidate classpath entry before run", "") val YvirtClasses = false // too embryonic to even expose as a -Y //BooleanSetting ("-Yvirtual-classes", "Support virtual classes") val YdisableUnreachablePrevention = BooleanSetting("-Ydisable-unreachable-prevention", "Disable the prevention of unreachable blocks in code generation.") val YnoLoadImplClass = BooleanSetting ("-Yno-load-impl-class", "Do not load $class.class files.") From 8f25a5125ea0974e42e6c365a3331163d0a1e154 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 26 Jun 2014 11:24:37 +0200 Subject: [PATCH 400/826] Eclipse project: repl depends on compiler/lib projects --- src/eclipse/repl/.classpath | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/eclipse/repl/.classpath b/src/eclipse/repl/.classpath index 601a231aeb2e..8fed2a3f616d 100644 --- a/src/eclipse/repl/.classpath +++ b/src/eclipse/repl/.classpath @@ -1,11 +1,11 @@ - - - - - - - - + + + + + + + + From 4b333fbf7a38be11e568bd71e2dc5dca00e3bce6 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Mon, 23 Jun 2014 17:49:23 +0200 Subject: [PATCH 401/826] Minor cleanup in AbstractReporter. --- src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala b/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala index 6c592ead0d50..5e4914fa832e 100644 --- a/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala +++ b/src/compiler/scala/tools/nsc/reporters/AbstractReporter.scala @@ -30,6 +30,7 @@ abstract class AbstractReporter extends Reporter { private def isVerbose = settings.verbose.value private def noWarnings = settings.nowarnings.value private def isPromptSet = settings.prompt.value + private def isDebug = settings.debug protected def info0(pos: Position, msg: String, severity: Severity, force: Boolean) { if (severity == INFO) { @@ -46,7 +47,7 @@ abstract class AbstractReporter extends Reporter { severity.count += 1 display(pos, msg, severity) } - else if (settings.debug) { + else if (isDebug) { severity.count += 1 display(pos, "[ suppressed ] " + msg, severity) } @@ -57,6 +58,7 @@ abstract class AbstractReporter extends Reporter { } } + /** Logs a position and returns true if it was already logged. * @note Two positions are considered identical for logging if they have the same point. */ From 638b4c3f5b5721b68a6af97e237b4f056c2da7ed Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 26 Jun 2014 11:22:04 +0200 Subject: [PATCH 402/826] Regularize `comment` hook method This is currently pretty borken, but let's at least not clutter innocent interfaces with this functionality. Moved `comment` (as `signalParsedDocComment`) next to the other hook methods in `Global`. For now, it calls the old `reporter.comment` hook method. As soon as the IDE is refactored to receive comments properly, the deprecated `Reporter#comment` method can be removed. --- src/compiler/scala/tools/nsc/CompilationUnits.scala | 7 ++----- src/compiler/scala/tools/nsc/Global.scala | 8 ++++++++ src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala | 7 ++++--- 3 files changed, 14 insertions(+), 8 deletions(-) diff --git a/src/compiler/scala/tools/nsc/CompilationUnits.scala b/src/compiler/scala/tools/nsc/CompilationUnits.scala index f23bca77cd4f..0a356ed7b679 100644 --- a/src/compiler/scala/tools/nsc/CompilationUnits.scala +++ b/src/compiler/scala/tools/nsc/CompilationUnits.scala @@ -135,11 +135,8 @@ trait CompilationUnits { global: Global => @deprecated("Call global.currentRun.reporting.uncheckedWarning directly instead.", "2.11.2") final def uncheckedWarning(pos: Position, msg: String): Unit = currentRun.reporting.uncheckedWarning(pos, msg) - // called by ScalaDocAnalyzer, overridden by the IDE (in Reporter) - // TODO: don't use reporter to communicate comments from parser to IDE! - @deprecated("This method will be removed.", "2.11.2") - final def comment(pos: Position, msg: String): Unit = reporter.comment(pos, msg) - + @deprecated("This method will be removed. It does nothing.", "2.11.2") + final def comment(pos: Position, msg: String): Unit = {} /** Is this about a .java source file? */ lazy val isJava = source.file.name.endsWith(".java") diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 572e579aca2e..72464cea8a7a 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -218,6 +218,14 @@ class Global(var currentSettings: Settings, var reporter: Reporter) /** Called from parser, which signals hereby that a method definition has been parsed. */ def signalParseProgress(pos: Position) {} + /** Called by ScalaDocAnalyzer when a doc comment has been parsed. */ + def signalParsedDocComment(comment: String, pos: Position) = { + // TODO: this is all very borken (only works for scaladoc comments, not regular ones) + // --> add hooks to parser and refactor Interactive global to handle comments directly + // in any case don't use reporter for parser hooks + reporter.comment(pos, comment) + } + /** Register new context; called for every created context */ def registerContext(c: analyzer.Context) { diff --git a/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala b/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala index ccf18b76de52..cbf8ff22ba82 100644 --- a/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala +++ b/src/scaladoc/scala/tools/nsc/doc/ScaladocAnalyzer.scala @@ -208,7 +208,7 @@ abstract class ScaladocSyntaxAnalyzer[G <: Global](val global: G) extends Syntax super.skipDocComment() } override def skipBlockComment(): Unit = { - inDocComment = false + inDocComment = false // ??? this means docBuffer won't receive contents of this comment??? docBuffer = new StringBuilder("/*") super.skipBlockComment() } @@ -217,9 +217,10 @@ abstract class ScaladocSyntaxAnalyzer[G <: Global](val global: G) extends Syntax def foundStarComment(start: Int, end: Int) = try { val str = docBuffer.toString val pos = Position.range(unit.source, start, start, end) - unit.comment(pos, str) - if (inDocComment) + if (inDocComment) { + signalParsedDocComment(str, pos) lastDoc = DocComment(str, pos) + } true } finally { docBuffer = null From 64ebac245d58221814f9c9375927e3f2e7a2d4f0 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 26 Jun 2014 11:21:15 +0200 Subject: [PATCH 403/826] Move more parsing hooks out of reporting. Create a trait Parsing, which, like Reporting, factors our functionality from Global (aka. "the cake"), that is related to global aspects of configuring parsing. --- src/compiler/scala/tools/nsc/Global.scala | 5 +-- src/compiler/scala/tools/nsc/Parsing.scala | 36 +++++++++++++++++++ src/compiler/scala/tools/nsc/Reporting.scala | 15 -------- .../scala/tools/nsc/ast/parser/Parsers.scala | 2 +- .../scala/tools/nsc/ast/parser/Scanners.scala | 2 +- .../tools/nsc/ast/parser/SyntaxAnalyzer.scala | 2 +- .../scala/tools/nsc/javac/JavaScanners.scala | 2 +- .../scala/tools/nsc/reporters/Reporter.scala | 4 +-- .../scala/tools/nsc/interpreter/IMain.scala | 2 +- 9 files changed, 46 insertions(+), 24 deletions(-) create mode 100644 src/compiler/scala/tools/nsc/Parsing.scala diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 72464cea8a7a..0ee7f4e21c36 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -45,7 +45,8 @@ class Global(var currentSettings: Settings, var reporter: Reporter) with Printers with DocComments with Positions - with Reporting { self => + with Reporting + with Parsing { self => // the mirror -------------------------------------------------- @@ -1163,7 +1164,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) /** A Run is a single execution of the compiler on a set of units. */ - class Run extends RunContextApi with RunReporting { + class Run extends RunContextApi with RunReporting with RunParsing { /** Have been running into too many init order issues with Run * during erroneous conditions. Moved all these vals up to the * top of the file so at least they're not trivially null. diff --git a/src/compiler/scala/tools/nsc/Parsing.scala b/src/compiler/scala/tools/nsc/Parsing.scala new file mode 100644 index 000000000000..4dd3c3f37841 --- /dev/null +++ b/src/compiler/scala/tools/nsc/Parsing.scala @@ -0,0 +1,36 @@ +/* NSC -- new Scala compiler + * Copyright 2005-2014 LAMP/EPFL, Typesafe Inc. + * @author Adriaan Moors + */ + +package scala +package tools.nsc + +import scala.reflect.internal.Positions +import scala.tools.nsc.reporters.Reporter + +/** Similar to Reporting: gather global functionality specific to parsing. + */ +trait Parsing { self : Positions with Reporting => + def currentRun: RunParsing + + trait RunParsing { + val parsing: PerRunParsing = new PerRunParsing + } + + class PerRunParsing { + // for repl + private[this] var incompleteHandler: (Position, String) => Unit = null + def withIncompleteHandler[T](handler: (Position, String) => Unit)(thunk: => T) = { + val saved = incompleteHandler + incompleteHandler = handler + try thunk + finally incompleteHandler = saved + } + + def incompleteHandled = incompleteHandler != null + def incompleteInputError(pos: Position, msg: String): Unit = + if (incompleteHandled) incompleteHandler(pos, msg) + else reporter.error(pos, msg) + } +} \ No newline at end of file diff --git a/src/compiler/scala/tools/nsc/Reporting.scala b/src/compiler/scala/tools/nsc/Reporting.scala index 0263586418a0..b164f395fe55 100644 --- a/src/compiler/scala/tools/nsc/Reporting.scala +++ b/src/compiler/scala/tools/nsc/Reporting.scala @@ -104,20 +104,5 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w if (settings.fatalWarnings && reporter.hasWarnings) reporter.error(NoPosition, "No warnings can be incurred under -Xfatal-warnings.") } - - // for repl - private[this] var incompleteHandler: (Position, String) => Unit = null - def withIncompleteHandler[T](handler: (Position, String) => Unit)(thunk: => T) = { - val saved = incompleteHandler - incompleteHandler = handler - try thunk - finally incompleteHandler = saved - } - - def incompleteHandled = incompleteHandler != null - def incompleteInputError(pos: Position, msg: String): Unit = - if (incompleteHandled) incompleteHandler(pos, msg) - else reporter.error(pos, msg) - } } \ No newline at end of file diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index 883fd31dbc99..97cb543e341a 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -234,7 +234,7 @@ self => override def incompleteInputError(msg: String) { val offset = source.content.length - 1 if (smartParsing) syntaxErrors += ((offset, msg)) - else currentRun.reporting.incompleteInputError(o2p(offset), msg) + else currentRun.parsing.incompleteInputError(o2p(offset), msg) } /** parse unit. If there are inbalanced braces, diff --git a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala index 572497ac9010..d01b3abe4f57 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala @@ -1261,7 +1261,7 @@ trait Scanners extends ScannersCommon { override def deprecationWarning(off: Offset, msg: String) = currentRun.reporting.deprecationWarning(unit.position(off), msg) override def error (off: Offset, msg: String) = reporter.error(unit.position(off), msg) - override def incompleteInputError(off: Offset, msg: String) = currentRun.reporting.incompleteInputError(unit.position(off), msg) + override def incompleteInputError(off: Offset, msg: String) = currentRun.parsing.incompleteInputError(unit.position(off), msg) private var bracePatches: List[BracePatch] = patches diff --git a/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala b/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala index 64b762696e37..df2073785b84 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/SyntaxAnalyzer.scala @@ -83,7 +83,7 @@ abstract class SyntaxAnalyzer extends SubComponent with Parsers with MarkupParse private def initialUnitBody(unit: CompilationUnit): Tree = { if (unit.isJava) new JavaUnitParser(unit).parse() - else if (currentRun.reporting.incompleteHandled) newUnitParser(unit).parse() + else if (currentRun.parsing.incompleteHandled) newUnitParser(unit).parse() else newUnitParser(unit).smartParse() } diff --git a/src/compiler/scala/tools/nsc/javac/JavaScanners.scala b/src/compiler/scala/tools/nsc/javac/JavaScanners.scala index bddcf6567cb1..ac86dfd66510 100644 --- a/src/compiler/scala/tools/nsc/javac/JavaScanners.scala +++ b/src/compiler/scala/tools/nsc/javac/JavaScanners.scala @@ -861,7 +861,7 @@ trait JavaScanners extends ast.parser.ScannersCommon { in = new JavaCharArrayReader(unit.source.content, !settings.nouescape.value, syntaxError) init() def error (pos: Int, msg: String) = reporter.error(pos, msg) - def incompleteInputError(pos: Int, msg: String) = currentRun.reporting.incompleteInputError(pos, msg) + def incompleteInputError(pos: Int, msg: String) = currentRun.parsing.incompleteInputError(pos, msg) def deprecationWarning(pos: Int, msg: String) = currentRun.reporting.deprecationWarning(pos, msg) implicit def g2p(pos: Int): Position = Position.offset(unit.source, pos) } diff --git a/src/compiler/scala/tools/nsc/reporters/Reporter.scala b/src/compiler/scala/tools/nsc/reporters/Reporter.scala index 5b576a547d4c..3d688efae1bc 100644 --- a/src/compiler/scala/tools/nsc/reporters/Reporter.scala +++ b/src/compiler/scala/tools/nsc/reporters/Reporter.scala @@ -13,8 +13,8 @@ import scala.reflect.internal.util._ * This describes the internal interface for issuing information, warnings and errors. * The only abstract method in this class must be info0. * - * TODO: Move external clients (sbt/ide/partest) to reflect.internal.Reporter - * This interface should be considered private to the compiler. + * TODO: Move external clients (sbt/ide/partest) to reflect.internal.Reporter, + * and remove this class. */ abstract class Reporter extends scala.reflect.internal.Reporter { /** Informational messages. If `!force`, they may be suppressed. */ diff --git a/src/repl/scala/tools/nsc/interpreter/IMain.scala b/src/repl/scala/tools/nsc/interpreter/IMain.scala index 8ea8759ee5e7..6e30b73e0ef6 100644 --- a/src/repl/scala/tools/nsc/interpreter/IMain.scala +++ b/src/repl/scala/tools/nsc/interpreter/IMain.scala @@ -1121,7 +1121,7 @@ class IMain(@BeanProperty val factory: ScriptEngineFactory, initialSettings: Set def apply(line: String): Result = debugging(s"""parse("$line")""") { var isIncomplete = false - currentRun.reporting.withIncompleteHandler((_, _) => isIncomplete = true) { + currentRun.parsing.withIncompleteHandler((_, _) => isIncomplete = true) { reporter.reset() val trees = newUnitParser(line).parseStats() if (reporter.hasErrors) Error From 2aa1f1e249596b6d629be35170bdbea7ea14cbe2 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Mon, 7 Jul 2014 16:08:57 +0200 Subject: [PATCH 404/826] Remove another redundant forwarder In this case, `infer.issue -> context.issue`. Forwarders are dead weight that cause bit rot. They tend to acquire functionality, clutter their defining interface and dilute the purpose of the method they forward to. --- src/compiler/scala/tools/nsc/typechecker/Infer.scala | 2 -- .../scala/tools/nsc/typechecker/PatternTypers.scala | 2 +- src/compiler/scala/tools/nsc/typechecker/Typers.scala | 8 ++++---- 3 files changed, 5 insertions(+), 7 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index a3f1da60ce94..04657c908b5d 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -199,8 +199,6 @@ trait Infer extends Checkable { def getContext = context - def issue(err: AbsTypeError): Unit = context.issue(err) - def explainTypes(tp1: Type, tp2: Type) = { if (context.reportErrors) withDisambiguation(List(), tp1, tp2)(global.explainTypes(tp1, tp2)) diff --git a/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala b/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala index cf3f265f0cfe..da0e67a2a523 100644 --- a/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala @@ -261,7 +261,7 @@ trait PatternTypers { def doTypedUnapply(tree: Tree, fun0: Tree, fun: Tree, args: List[Tree], mode: Mode, pt: Type): Tree = { def duplErrTree = setError(treeCopy.Apply(tree, fun0, args)) - def duplErrorTree(err: AbsTypeError) = { issue(err); duplErrTree } + def duplErrorTree(err: AbsTypeError) = { context.issue(err); duplErrTree } if (args.length > MaxTupleArity) return duplErrorTree(TooManyArgsPatternError(fun)) diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 70f44c4fc60a..d35319bb8c1e 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -3149,7 +3149,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper def doTypedApply(tree: Tree, fun0: Tree, args: List[Tree], mode: Mode, pt: Type): Tree = { // TODO_NMT: check the assumption that args nonEmpty def duplErrTree = setError(treeCopy.Apply(tree, fun0, args)) - def duplErrorTree(err: AbsTypeError) = { issue(err); duplErrTree } + def duplErrorTree(err: AbsTypeError) = { context.issue(err); duplErrTree } def preSelectOverloaded(fun: Tree): Tree = { if (fun.hasSymbolField && fun.symbol.isOverloaded) { @@ -4395,7 +4395,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper case _ => () } } - typeErrors foreach issue + typeErrors foreach context.issue setError(treeCopy.Apply(tree, fun, args)) } @@ -4449,7 +4449,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper doTypedApply(tree, fun2, args, mode, pt) case err: SilentTypeError => onError({ - err.reportableErrors foreach issue + err.reportableErrors foreach context.issue args foreach (arg => typed(arg, mode, ErrorType)) setError(tree) }) @@ -4686,7 +4686,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper else // before failing due to access, try a dynamic call. asDynamicCall getOrElse { - issue(accessibleError.get) + context.issue(accessibleError.get) setError(tree) } case _ => From 67651e220a6a4d1d1ee1004766d5b1e33fd46531 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Mon, 7 Jul 2014 14:53:22 +0200 Subject: [PATCH 405/826] Simplify (ambiguous) error issuing. The two functional differences are: - always add the diagnostics string - check erroneousness in `issueAmbiguousTypeErrorUnlessErroneous`, before even constructing the error message. Consider this nugget: ``` - def issueAmbiguousError(pre: Type, sym1: Symbol, sym2: Symbol, err: AbsTypeError) { - issueCommon(err) { case _ if ambiguousErrors => - if (!pre.isErroneous && !sym1.isErroneous && !sym2.isErroneous) ``` I'd like to state for the record that the if-erroneous in the case of the partial function looked super-dodgy: it meant that, when `ambiguousErrors`, `issueCommon` would not get to the `else` branches that buffer or throw, and if the erroneous condition was met, nothing would be issued/buffered/thrown. This refactoring checks this condition up front. --- .../tools/nsc/typechecker/ContextErrors.scala | 38 +++++++++---------- .../tools/nsc/typechecker/Contexts.scala | 22 ++--------- .../tools/nsc/typechecker/Implicits.scala | 1 + test/files/neg/t3909.check | 1 + 4 files changed, 23 insertions(+), 39 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala index 9715fdaf0042..5c31685bcde9 100644 --- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala @@ -90,10 +90,6 @@ trait ContextErrors { issueTypeError(SymbolTypeError(sym, msg)) } - def issueAmbiguousTypeError(pre: Type, sym1: Symbol, sym2: Symbol, err: AmbiguousTypeError)(implicit context: Context) { - context.issueAmbiguousError(pre, sym1, sym2, err) - } - def issueTypeError(err: AbsTypeError)(implicit context: Context) { context.issue(err) } def typeErrorMsg(found: Type, req: Type) = "type mismatch" + foundReqMsg(found, req) @@ -883,19 +879,21 @@ trait ContextErrors { val WrongNumber, NoParams, ArgsDoNotConform = Value } - private def ambiguousErrorMsgPos(pos: Position, pre: Type, sym1: Symbol, sym2: Symbol, rest: String) = - if (sym1.hasDefault && sym2.hasDefault && sym1.enclClass == sym2.enclClass) { - val methodName = nme.defaultGetterToMethod(sym1.name) - (sym1.enclClass.pos, - "in "+ sym1.enclClass +", multiple overloaded alternatives of " + methodName + - " define default arguments") - } else { - (pos, - ("ambiguous reference to overloaded definition,\n" + - "both " + sym1 + sym1.locationString + " of type " + pre.memberType(sym1) + - "\nand " + sym2 + sym2.locationString + " of type " + pre.memberType(sym2) + - "\nmatch " + rest) - ) + private def issueAmbiguousTypeErrorUnlessErroneous(pos: Position, pre: Type, sym1: Symbol, sym2: Symbol, rest: String): Unit = + if (!(pre.isErroneous || sym1.isErroneous || sym2.isErroneous)) { + if (sym1.hasDefault && sym2.hasDefault && sym1.enclClass == sym2.enclClass) { + val methodName = nme.defaultGetterToMethod(sym1.name) + context.issueAmbiguousError(AmbiguousTypeError(sym1.enclClass.pos, + "in "+ sym1.enclClass +", multiple overloaded alternatives of " + methodName + + " define default arguments")) + } else { + context.issueAmbiguousError(AmbiguousTypeError(pos, + ("ambiguous reference to overloaded definition,\n" + + "both " + sym1 + sym1.locationString + " of type " + pre.memberType(sym1) + + "\nand " + sym2 + sym2.locationString + " of type " + pre.memberType(sym2) + + "\nmatch " + rest) + )) + } } def AccessError(tree: Tree, sym: Symbol, ctx: Context, explanation: String): AbsTypeError = @@ -952,8 +950,7 @@ trait ContextErrors { val msg0 = "argument types " + argtpes.mkString("(", ",", ")") + (if (pt == WildcardType) "" else " and expected result type " + pt) - val (pos, msg) = ambiguousErrorMsgPos(tree.pos, pre, best, firstCompeting, msg0) - issueAmbiguousTypeError(pre, best, firstCompeting, AmbiguousTypeError(pos, msg)) + issueAmbiguousTypeErrorUnlessErroneous(tree.pos, pre, best, firstCompeting, msg0) setErrorOnLastTry(lastTry, tree) } else setError(tree) // do not even try further attempts because they should all fail // even if this is not the last attempt (because of the SO's possibility on the horizon) @@ -966,8 +963,7 @@ trait ContextErrors { } def AmbiguousExprAlternativeError(tree: Tree, pre: Type, best: Symbol, firstCompeting: Symbol, pt: Type, lastTry: Boolean) = { - val (pos, msg) = ambiguousErrorMsgPos(tree.pos, pre, best, firstCompeting, "expected type " + pt) - issueAmbiguousTypeError(pre, best, firstCompeting, AmbiguousTypeError(pos, msg)) + issueAmbiguousTypeErrorUnlessErroneous(tree.pos, pre, best, firstCompeting, "expected type " + pt) setErrorOnLastTry(lastTry, tree) } diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 72ca9b879aa8..aa2394897c03 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -543,37 +543,23 @@ trait Contexts { self: Analyzer => private def unitError(pos: Position, msg: String): Unit = if (checking) onTreeCheckerError(pos, msg) else reporter.error(pos, msg) - @inline private def issueCommon(err: AbsTypeError)(pf: PartialFunction[AbsTypeError, Unit]) { + @inline private def issueCommon(err: AbsTypeError, reportError: Boolean) { // TODO: are errors allowed to have pos == NoPosition?? // if not, Jason suggests doing: val pos = err.errPos.orElse( { devWarning("Que?"); context.tree.pos }) if (settings.Yissuedebug) { log("issue error: " + err.errMsg) (new Exception).printStackTrace() } - if (pf isDefinedAt err) pf(err) + if (reportError) unitError(err.errPos, addDiagString(err.errMsg)) else if (bufferErrors) { reportBuffer += err } else throw new TypeError(err.errPos, err.errMsg) } /** Issue/buffer/throw the given type error according to the current mode for error reporting. */ - def issue(err: AbsTypeError) { - issueCommon(err) { case _ if reportErrors => - unitError(err.errPos, addDiagString(err.errMsg)) - } - } + private[typechecker] def issue(err: AbsTypeError) = issueCommon(err, reportErrors) /** Issue/buffer/throw the given implicit ambiguity error according to the current mode for error reporting. */ - def issueAmbiguousError(pre: Type, sym1: Symbol, sym2: Symbol, err: AbsTypeError) { - issueCommon(err) { case _ if ambiguousErrors => - if (!pre.isErroneous && !sym1.isErroneous && !sym2.isErroneous) - unitError(err.errPos, err.errMsg) - } - } - - /** Issue/buffer/throw the given implicit ambiguity error according to the current mode for error reporting. */ - def issueAmbiguousError(err: AbsTypeError) { - issueCommon(err) { case _ if ambiguousErrors => unitError(err.errPos, addDiagString(err.errMsg)) } - } + private[typechecker] def issueAmbiguousError(err: AbsTypeError) = issueCommon(err, ambiguousErrors) /** Issue/throw the given `err` according to the current mode for error reporting. */ def error(pos: Position, err: Throwable) = diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index 73c3e6f0169e..6b5a70bffb0c 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -1381,6 +1381,7 @@ trait Implicits { def maybeInvalidConversionError(msg: String) { // We have to check context.ambiguousErrors even though we are calling "issueAmbiguousError" // which ostensibly does exactly that before issuing the error. Why? I have no idea. Test is pos/t7690. + // AM: I would guess it's because ambiguous errors will be buffered in silent mode if they are not reported if (context.ambiguousErrors) context.issueAmbiguousError(AmbiguousImplicitTypeError(tree, msg)) } diff --git a/test/files/neg/t3909.check b/test/files/neg/t3909.check index 7da0195607a4..052b49f855b5 100644 --- a/test/files/neg/t3909.check +++ b/test/files/neg/t3909.check @@ -1,4 +1,5 @@ t3909.scala:1: error: in object DO, multiple overloaded alternatives of m1 define default arguments +Error occurred in an application involving default arguments. object DO { ^ one error found From 5895e10adb3ec3e711cd48a9d0f0f9095c7f8ab9 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 8 Jul 2014 08:27:27 +0200 Subject: [PATCH 406/826] Concretize diagnostics: one boolean suffices for now. Once we get the next diagnostic, lets encapsulate them in an object, with a boolean flag for each one when it needs to trigger, and a nice message that should be presented to our delighted user. A list of Strings that is searched by contents is a bit fragile, and can't be very fast either. --- .../scala/tools/nsc/typechecker/Contexts.scala | 18 +++++++++--------- .../scala/tools/nsc/typechecker/Typers.scala | 3 +-- 2 files changed, 10 insertions(+), 11 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index aa2394897c03..7cb2ad7ac525 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -265,8 +265,9 @@ trait Contexts { self: Analyzer => def defaultModeForTyped: Mode = if (inTypeConstructorAllowed) Mode.NOmode else Mode.EXPRmode - /** These messages are printed when issuing an error */ - var diagnostic: List[String] = Nil + /** To enrich error messages involving default arguments. + When extending the notion, group diagnostics in an object. */ + var diagUsedDefaults: Boolean = false /** Saved type bounds for type parameters which are narrowed in a GADT. */ var savedTypeBounds: List[(Symbol, Type)] = List() @@ -452,7 +453,7 @@ trait Contexts { self: Analyzer => // Fields that are directly propagated c.variance = variance - c.diagnostic = diagnostic + c.diagUsedDefaults = diagUsedDefaults c.openImplicits = openImplicits c.contextMode = contextMode // note: ConstructorSuffix, a bit within `mode`, is conditionally overwritten below. c._reportBuffer = reportBuffer @@ -532,16 +533,15 @@ trait Contexts { self: Analyzer => // // Error and warning issuance // - private def addDiagString(msg: String) = { - val ds = - if (diagnostic.isEmpty) "" - else diagnostic.mkString("\n","\n", "") - if (msg endsWith ds) msg else msg + ds + val diagUsedDefaultsMsg = "Error occurred in an application involving default arguments." + if (diagUsedDefaults && !(msg endsWith diagUsedDefaultsMsg)) msg + "\n" + diagUsedDefaultsMsg + else msg } private def unitError(pos: Position, msg: String): Unit = - if (checking) onTreeCheckerError(pos, msg) else reporter.error(pos, msg) + if (checking) onTreeCheckerError(pos, msg) + else reporter.error(pos, msg) @inline private def issueCommon(err: AbsTypeError, reportError: Boolean) { // TODO: are errors allowed to have pos == NoPosition?? diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index d35319bb8c1e..e0af229d3aba 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -3357,8 +3357,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper duplErrTree } else if (lencmp2 == 0) { // useful when a default doesn't match parameter type, e.g. def f[T](x:T="a"); f[Int]() - val note = "Error occurred in an application involving default arguments." - if (!(context.diagnostic contains note)) context.diagnostic = note :: context.diagnostic + context.diagUsedDefaults = true doTypedApply(tree, if (blockIsEmpty) fun else fun1, allArgs, mode, pt) } else { rollbackNamesDefaultsOwnerChanges() From 3fd4f47d7609e8818ea97e29e86af8b5ef09be9e Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 8 Jul 2014 12:24:03 +0200 Subject: [PATCH 407/826] Add errorCount to wean partest off Reporter$Severity Once a release with this method is out, move partest to use errorCount and cut ties with the Severity nested class, so we can move it to the right enclosing class. --- src/reflect/scala/reflect/internal/Reporting.scala | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/reflect/scala/reflect/internal/Reporting.scala b/src/reflect/scala/reflect/internal/Reporting.scala index 423127803eb5..f2de83bc5de2 100644 --- a/src/reflect/scala/reflect/internal/Reporting.scala +++ b/src/reflect/scala/reflect/internal/Reporting.scala @@ -89,6 +89,9 @@ abstract class Reporter { def count(severity: Severity): Int def resetCount(severity: Severity): Unit + def errorCount: Int = count(ERROR) + def warningCount: Int = count(WARNING) + def hasErrors: Boolean = count(ERROR) > 0 def hasWarnings: Boolean = count(WARNING) > 0 From a7407468be46799619f1b7ebe1f0975f3a6c2dbb Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Wed, 9 Jul 2014 11:46:32 +0200 Subject: [PATCH 408/826] Clarify divergentError comment --- src/compiler/scala/tools/nsc/typechecker/Implicits.scala | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index 6b5a70bffb0c..98cf9c78305e 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -857,7 +857,8 @@ trait Implicits { SearchFailure } else { if (search.isFailure) { - // We don't want errors that occur during checking implicit info + // Discard the divergentError we saved (if any), as well as all errors that are not of type DivergentImplicitTypeError + // We don't want errors that occur while checking the implicit info // to influence the check of further infos, but we should retain divergent implicit errors // (except for the one we already squirreled away) val saved = divergentError.getOrElse(null) From ac6dcad89a0121d5c5c78e373fe691a56f1103d4 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 8 Jul 2014 16:43:39 +0200 Subject: [PATCH 409/826] Extract the `makeNonSilent` method. Setting the scene of removing the reporting mode bits from `contextMode`. --- src/compiler/scala/tools/nsc/typechecker/Contexts.scala | 6 ++++++ src/compiler/scala/tools/nsc/typechecker/Namers.scala | 3 +-- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 7cb2ad7ac525..695932c87030 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -490,6 +490,12 @@ trait Contexts { self: Analyzer => c } + def makeNonSilent(newtree: Tree): Context = { + val c = make(newtree) + c.setReportErrors() + c + } + /** Make a silent child context does not allow implicits. Used to prevent chaining of implicit views. */ def makeImplicit(reportAmbiguousErrors: Boolean) = { val c = makeSilent(reportAmbiguousErrors) diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala index 7bbd81118aa1..fdff2f3076dc 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala @@ -1494,8 +1494,7 @@ trait Namers extends MethodSynthesis { case defn: MemberDef => val ainfos = defn.mods.annotations filterNot (_ eq null) map { ann => val ctx = typer.context - val annCtx = ctx.make(ann) - annCtx.setReportErrors() + val annCtx = ctx.makeNonSilent(ann) // need to be lazy, #1782. beforeTyper to allow inferView in annotation args, SI-5892. AnnotationInfo lazily { enteringTyper(newTyper(annCtx) typedAnnotation ann) From 543bb3e0b60cd1e1d4a3e3be19ec90256cc13151 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 8 Jul 2014 16:44:23 +0200 Subject: [PATCH 410/826] Encapsulate `TryTwice` as a class, move to `Context`. All functionality that's closely tied to the error buffer should be in `Context`'s reporting infrastructure. (called `ContextReporter`, soon to follow.) --- .../tools/nsc/typechecker/Contexts.scala | 40 +++++ .../scala/tools/nsc/typechecker/Infer.scala | 138 +++++++----------- 2 files changed, 96 insertions(+), 82 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 695932c87030..199209c5faf5 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -365,6 +365,46 @@ trait Contexts { self: Analyzer => reportBuffer.clearAllWarnings() } + + /** Try inference twice, once without views and once with views, + * unless views are already disabled. + */ + abstract class TryTwice { + def tryOnce(isLastTry: Boolean): Unit + + def apply(): Unit = + if (implicitsEnabled) { + val savedContextMode = contextMode + var fallback = false + setBufferErrors() + // We cache the current buffer because it is impossible to + // distinguish errors that occurred before entering tryTwice + // and our first attempt in 'withImplicitsDisabled'. If the + // first attempt fails we try with implicits on *and* clean + // buffer but that would also flush any pre-tryTwice valid + // errors, hence some manual buffer tweaking is necessary. + val errorsToRestore = flushAndReturnBuffer() + try { + withImplicitsDisabled(tryOnce(false)) + if (hasErrors) { + fallback = true + contextMode = savedContextMode + flushBuffer() + tryOnce(true) + } + } catch { + case ex: CyclicReference => throw ex + case ex: TypeError => // recoverable cyclic references + contextMode = savedContextMode + if (!fallback) tryOnce(true) else () + } finally { + contextMode = savedContextMode + updateBuffer(errorsToRestore) + } + } + else tryOnce(true) + } + // // Temporary mode adjustment // diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index 04657c908b5d..cb985ddaf6cd 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -1264,33 +1264,36 @@ trait Infer extends Checkable { * If no alternative matches `pt`, take the parameterless one anyway. */ def inferExprAlternative(tree: Tree, pt: Type): Tree = { - def tryOurBests(pre: Type, alts: List[Symbol], isSecondTry: Boolean): Unit = { - val alts0 = alts filter (alt => isWeaklyCompatible(pre memberType alt, pt)) - val alts1 = if (alts0.isEmpty) alts else alts0 - val bests = bestAlternatives(alts1) { (sym1, sym2) => - val tp1 = pre memberType sym1 - val tp2 = pre memberType sym2 - - ( (tp2 eq ErrorType) - || isWeaklyCompatible(tp1, pt) && !isWeaklyCompatible(tp2, pt) - || isStrictlyMoreSpecific(tp1, tp2, sym1, sym2) - ) - } - // todo: missing test case for bests.isEmpty - bests match { - case best :: Nil => tree setSymbol best setType (pre memberType best) - case best :: competing :: _ if alts0.nonEmpty => - // SI-6912 Don't give up and leave an OverloadedType on the tree. - // Originally I wrote this as `if (secondTry) ... `, but `tryTwice` won't attempt the second try - // unless an error is issued. We're not issuing an error, in the assumption that it would be - // spurious in light of the erroneous expected type - if (pt.isErroneous) setError(tree) - else AmbiguousExprAlternativeError(tree, pre, best, competing, pt, isSecondTry) - case _ => if (bests.isEmpty || alts0.isEmpty) NoBestExprAlternativeError(tree, pt, isSecondTry) + val c = context + class InferTwice(pre: Type, alts: List[Symbol]) extends c.TryTwice { + def tryOnce(isSecondTry: Boolean): Unit = { + val alts0 = alts filter (alt => isWeaklyCompatible(pre memberType alt, pt)) + val alts1 = if (alts0.isEmpty) alts else alts0 + val bests = bestAlternatives(alts1) { (sym1, sym2) => + val tp1 = pre memberType sym1 + val tp2 = pre memberType sym2 + + ( (tp2 eq ErrorType) + || isWeaklyCompatible(tp1, pt) && !isWeaklyCompatible(tp2, pt) + || isStrictlyMoreSpecific(tp1, tp2, sym1, sym2) + ) + } + // todo: missing test case for bests.isEmpty + bests match { + case best :: Nil => tree setSymbol best setType (pre memberType best) + case best :: competing :: _ if alts0.nonEmpty => + // SI-6912 Don't give up and leave an OverloadedType on the tree. + // Originally I wrote this as `if (secondTry) ... `, but `tryTwice` won't attempt the second try + // unless an error is issued. We're not issuing an error, in the assumption that it would be + // spurious in light of the erroneous expected type + if (pt.isErroneous) setError(tree) + else AmbiguousExprAlternativeError(tree, pre, best, competing, pt, isSecondTry) + case _ => if (bests.isEmpty || alts0.isEmpty) NoBestExprAlternativeError(tree, pt, isSecondTry) + } } } tree.tpe match { - case OverloadedType(pre, alts) => tryTwice(tryOurBests(pre, alts, _)) ; tree + case OverloadedType(pre, alts) => (new InferTwice(pre, alts)).apply() ; tree case _ => tree } } @@ -1368,70 +1371,41 @@ trait Infer extends Checkable { * @pre tree.tpe is an OverloadedType. */ def inferMethodAlternative(tree: Tree, undetparams: List[Symbol], argtpes0: List[Type], pt0: Type): Unit = { - val OverloadedType(pre, alts) = tree.tpe - var varargsStar = false - val argtpes = argtpes0 mapConserve { - case RepeatedType(tp) => varargsStar = true ; tp - case tp => tp - } - def followType(sym: Symbol) = followApply(pre memberType sym) - def bestForExpectedType(pt: Type, isLastTry: Boolean): Unit = { - val applicable0 = alts filter (alt => context inSilentMode isApplicable(undetparams, followType(alt), argtpes, pt)) - val applicable = overloadsToConsiderBySpecificity(applicable0, argtpes, varargsStar) - val ranked = bestAlternatives(applicable)((sym1, sym2) => - isStrictlyMoreSpecific(followType(sym1), followType(sym2), sym1, sym2) - ) - ranked match { - case best :: competing :: _ => AmbiguousMethodAlternativeError(tree, pre, best, competing, argtpes, pt, isLastTry) // ambiguous - case best :: Nil => tree setSymbol best setType (pre memberType best) // success - case Nil if pt.isWildcard => NoBestMethodAlternativeError(tree, argtpes, pt, isLastTry) // failed - case Nil => bestForExpectedType(WildcardType, isLastTry) // failed, but retry with WildcardType - } - } - // This potentially makes up to four attempts: tryTwice may execute + // This potentially makes up to four attempts: tryOnce may execute // with and without views enabled, and bestForExpectedType will try again // with pt = WildcardType if it fails with pt != WildcardType. - tryTwice { isLastTry => - val pt = if (pt0.typeSymbol == UnitClass) WildcardType else pt0 - debuglog(s"infer method alt ${tree.symbol} with alternatives ${alts map pre.memberType} argtpes=$argtpes pt=$pt") - bestForExpectedType(pt, isLastTry) - } - } + val c = context + class InferTwice extends c.TryTwice { + private[this] val OverloadedType(pre, alts) = tree.tpe + private[this] var varargsStar = false + private[this] val argtpes = argtpes0 mapConserve { + case RepeatedType(tp) => varargsStar = true ; tp + case tp => tp + } - /** Try inference twice, once without views and once with views, - * unless views are already disabled. - */ - def tryTwice(infer: Boolean => Unit): Unit = { - if (context.implicitsEnabled) { - val savedContextMode = context.contextMode - var fallback = false - context.setBufferErrors() - // We cache the current buffer because it is impossible to - // distinguish errors that occurred before entering tryTwice - // and our first attempt in 'withImplicitsDisabled'. If the - // first attempt fails we try with implicits on *and* clean - // buffer but that would also flush any pre-tryTwice valid - // errors, hence some manual buffer tweaking is necessary. - val errorsToRestore = context.flushAndReturnBuffer() - try { - context.withImplicitsDisabled(infer(false)) - if (context.hasErrors) { - fallback = true - context.contextMode = savedContextMode - context.flushBuffer() - infer(true) + private def followType(sym: Symbol) = followApply(pre memberType sym) + private def bestForExpectedType(pt: Type, isLastTry: Boolean): Unit = { + val applicable0 = alts filter (alt => context inSilentMode isApplicable(undetparams, followType(alt), argtpes, pt)) + val applicable = overloadsToConsiderBySpecificity(applicable0, argtpes, varargsStar) + val ranked = bestAlternatives(applicable)((sym1, sym2) => + isStrictlyMoreSpecific(followType(sym1), followType(sym2), sym1, sym2) + ) + ranked match { + case best :: competing :: _ => AmbiguousMethodAlternativeError(tree, pre, best, competing, argtpes, pt, isLastTry) // ambiguous + case best :: Nil => tree setSymbol best setType (pre memberType best) // success + case Nil if pt.isWildcard => NoBestMethodAlternativeError(tree, argtpes, pt, isLastTry) // failed + case Nil => bestForExpectedType(WildcardType, isLastTry) // failed, but retry with WildcardType } - } catch { - case ex: CyclicReference => throw ex - case ex: TypeError => // recoverable cyclic references - context.contextMode = savedContextMode - if (!fallback) infer(true) else () - } finally { - context.contextMode = savedContextMode - context.updateBuffer(errorsToRestore) + } + + private[this] val pt = if (pt0.typeSymbol == UnitClass) WildcardType else pt0 + def tryOnce(isLastTry: Boolean): Unit = { + debuglog(s"infer method alt ${tree.symbol} with alternatives ${alts map pre.memberType} argtpes=$argtpes pt=$pt") + bestForExpectedType(pt, isLastTry) } } - else infer(true) + + (new InferTwice).apply() } /** Assign `tree` the type of all polymorphic alternatives From b8503f6cf937b739341a6a387800c4542e81ae77 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Wed, 9 Jul 2014 11:32:58 +0200 Subject: [PATCH 411/826] Restrict `contextMode` fiddling to `Context` Introduce `initRootContext` to set the relevant bits. --- .../scala/tools/nsc/transform/Erasure.scala | 2 +- .../nsc/transform/TypingTransformers.scala | 6 ++--- .../tools/nsc/typechecker/Contexts.scala | 26 ++++++++++++++++--- .../scala/tools/reflect/ToolBoxFactory.scala | 2 +- 4 files changed, 28 insertions(+), 8 deletions(-) diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala index ec4deb6be03e..54bcc9e93e7e 100644 --- a/src/compiler/scala/tools/nsc/transform/Erasure.scala +++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala @@ -1133,7 +1133,7 @@ abstract class Erasure extends AddInterfaces val tree2 = mixinTransformer.transform(tree1) // debuglog("tree after addinterfaces: \n" + tree2) - newTyper(rootContext(unit, tree, erasedTypes = true)).typed(tree2) + newTyper(rootContextPostTyper(unit, tree)).typed(tree2) } } } diff --git a/src/compiler/scala/tools/nsc/transform/TypingTransformers.scala b/src/compiler/scala/tools/nsc/transform/TypingTransformers.scala index 3feadcd9b2e6..dc3313e2e43d 100644 --- a/src/compiler/scala/tools/nsc/transform/TypingTransformers.scala +++ b/src/compiler/scala/tools/nsc/transform/TypingTransformers.scala @@ -17,9 +17,9 @@ trait TypingTransformers { abstract class TypingTransformer(unit: CompilationUnit) extends Transformer { var localTyper: analyzer.Typer = if (phase.erasedTypes) - erasure.newTyper(erasure.rootContext(unit, EmptyTree, erasedTypes = true)).asInstanceOf[analyzer.Typer] - else - analyzer.newTyper(analyzer.rootContext(unit, EmptyTree, true)) + erasure.newTyper(erasure.rootContextPostTyper(unit, EmptyTree)).asInstanceOf[analyzer.Typer] + else // TODO: AM: should some phases use a regular rootContext instead of a post-typer one?? + analyzer.newTyper(analyzer.rootContextPostTyper(unit, EmptyTree)) protected var curTree: Tree = _ override final def atOwner[A](owner: Symbol)(trans: => A): A = atOwner(curTree, owner)(trans) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 199209c5faf5..6951ff2f0b0d 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -98,7 +98,7 @@ trait Contexts { self: Analyzer => } - def rootContext(unit: CompilationUnit, tree: Tree = EmptyTree, erasedTypes: Boolean = false): Context = { + def rootContext(unit: CompilationUnit, tree: Tree = EmptyTree): Context = { val rootImportsContext = (startContext /: rootImports(unit))((c, sym) => c.make(gen.mkWildcardImport(sym))) // there must be a scala.xml package when xml literals were parsed in this unit @@ -113,11 +113,17 @@ trait Contexts { self: Analyzer => else rootImportsContext.make(gen.mkImport(ScalaXmlPackage, nme.TopScope, nme.dollarScope)) val c = contextWithXML.make(tree, unit = unit) - if (erasedTypes) c.setThrowErrors() else c.setReportErrors() - c(EnrichmentEnabled | ImplicitsEnabled) = !erasedTypes + c.initRootContext() c } + def rootContextPostTyper(unit: CompilationUnit, tree: Tree = EmptyTree): Context = { + val c = rootContext(unit, tree) + c.initRootContextPostTyper() + c + } + + def resetContexts() { startContext.enclosingContextChain foreach { context => context.tree match { @@ -511,6 +517,20 @@ trait Contexts { self: Analyzer => c } + /** Use reporter (possibly buffered) for errors/warnings and enable implicit conversion **/ + def initRootContext(): Unit = { + setReportErrors() + this(EnrichmentEnabled | ImplicitsEnabled) = true + } + + /** Disable implicit conversion/enrichment, throw TypeError on error. + * TODO: can we phase out TypeError and uniformly rely on reporter? + */ + def initRootContextPostTyper(): Unit = { + setThrowErrors() + this(EnrichmentEnabled | ImplicitsEnabled) = false + } + def make(tree: Tree, owner: Symbol, scope: Scope): Context = // TODO SI-7345 Moving this optimization into the main overload of `make` causes all tests to fail. // even if it is extened to check that `unit == this.unit`. Why is this? diff --git a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala index 923297bafbee..1643e0061fc9 100644 --- a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala +++ b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala @@ -142,7 +142,7 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf => run.symSource(ownerClass) = NoAbstractFile // need to set file to something different from null, so that currentRun.defines works phase = run.typerPhase // need to set a phase to something <= typerPhase, otherwise implicits in typedSelect will be disabled globalPhase = run.typerPhase // amazing... looks like phase and globalPhase are different things, so we need to set them separately - currentTyper.context.setReportErrors() // need to manually set context mode, otherwise typer.silent will throw exceptions + currentTyper.context.initRootContext() // need to manually set context mode, otherwise typer.silent will throw exceptions reporter.reset() val expr3 = withContext(transform(currentTyper, expr2)) From dda3f241e7c47d13710be6a7e1ea9d5ef69709b2 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Wed, 9 Jul 2014 18:14:06 +0200 Subject: [PATCH 412/826] Rely less on intricacies of `contextMode`-based reporting. - when warning must not be suppressed, use `reporter.warning` - don't (implicitly) rely on `reporter.warning` being silent after typer --> don't do pure expression check after typer --- src/compiler/scala/tools/nsc/typechecker/Contexts.scala | 4 ++-- .../scala/tools/nsc/typechecker/TypeDiagnostics.scala | 6 +++--- src/compiler/scala/tools/nsc/typechecker/Typers.scala | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 6951ff2f0b0d..1010ceafe341 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -640,8 +640,8 @@ trait Contexts { self: Analyzer => } /** Issue/throw the given error message according to the current mode for error reporting. */ - def warning(pos: Position, msg: String, force: Boolean = false) { - if (reportErrors || force) reporter.warning(pos, msg) + def warning(pos: Position, msg: String) { + if (reportErrors) reporter.warning(pos, msg) else if (bufferErrors) reportBuffer += (pos -> msg) } diff --git a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala index 7440f69e9383..fbea69db5a89 100644 --- a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala +++ b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala @@ -572,11 +572,11 @@ trait TypeDiagnostics { } else f } def apply(tree: Tree): Tree = { - // Error suppression will squash some of these warnings unless we circumvent it. + // Error suppression (in context.warning) would squash some of these warnings. // It is presumed if you are using a -Y option you would really like to hear - // the warnings you've requested. + // the warnings you've requested; thus, use reporter.warning. if (settings.warnDeadCode && context.unit.exists && treeOK(tree) && exprOK) - context.warning(tree.pos, "dead code following this construct", force = true) + reporter.warning(tree.pos, "dead code following this construct") tree } diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index e0af229d3aba..ce031e9cd748 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -2990,7 +2990,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper ConstructorsOrderError(stat) } - if (treeInfo.isPureExprForWarningPurposes(result)) context.warning(stat.pos, + if (!isPastTyper && treeInfo.isPureExprForWarningPurposes(result)) context.warning(stat.pos, "a pure expression does nothing in statement position; " + "you may be omitting necessary parentheses" ) From ecda1010416305e5d5cbf9ba0c7f90ddee8a9737 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 10 Jul 2014 15:30:28 +0200 Subject: [PATCH 413/826] Make more explicit that TypeError is being thrown. `typer.TyperErrorGen.MacroCantExpandIncompatibleMacrosError` throws because the type checker it uses is at `NoContext`, which throws by default... This default is bad and is going to change, so make this code independent of that future sanity. TODO: don't use mutable state to determine position for the error --- .../tools/nsc/typechecker/ContextErrors.scala | 24 ++++++++++--------- .../scala/tools/nsc/typechecker/Macros.scala | 3 ++- 2 files changed, 15 insertions(+), 12 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala index 5c31685bcde9..028ac46058ca 100644 --- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala @@ -119,6 +119,19 @@ trait ContextErrors { import ErrorUtils._ + private def MacroIncompatibleEngineError(friendlyMessage: String, internalMessage: String) = { + def debugDiagnostic = s"(internal diagnostic: $internalMessage)" + val message = if (macroDebugLite || macroDebugVerbose) s"$friendlyMessage $debugDiagnostic" else friendlyMessage + // TODO: clean this up! (This is a more explicit version of what the code use to do, to reveal the issue.) + throw new TypeError(analyzer.lastTreeToTyper.pos, message) + } + + def MacroCantExpand210xMacrosError(internalMessage: String) = + MacroIncompatibleEngineError("can't expand macros compiled by previous versions of Scala", internalMessage) + + def MacroCantExpandIncompatibleMacrosError(internalMessage: String) = + MacroIncompatibleEngineError("macro cannot be expanded, because it was compiled by an incompatible macro engine", internalMessage) + trait TyperContextErrors { self: Typer => @@ -729,17 +742,6 @@ trait ContextErrors { NormalTypeError(expandee, "too many argument lists for " + fun) } - private def MacroIncompatibleEngineError(friendlyMessage: String, internalMessage: String) = { - def debugDiagnostic = s"(internal diagnostic: $internalMessage)" - val message = if (macroDebugLite || macroDebugVerbose) s"$friendlyMessage $debugDiagnostic" else friendlyMessage - issueNormalTypeError(lastTreeToTyper, message) - } - - def MacroCantExpand210xMacrosError(internalMessage: String) = - MacroIncompatibleEngineError("can't expand macros compiled by previous versions of Scala", internalMessage) - - def MacroCantExpandIncompatibleMacrosError(internalMessage: String) = - MacroIncompatibleEngineError("macro cannot be expanded, because it was compiled by an incompatible macro engine", internalMessage) case object MacroExpansionException extends Exception with scala.util.control.ControlThrowable diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala index 9c22688581e7..66152a6ac237 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala @@ -226,7 +226,8 @@ trait Macros extends MacroRuntimes with Traces with Helpers { val Apply(_, pickledPayload) = wrapped val payload = pickledPayload.map{ case Assign(k, v) => (unpickleAtom(k), unpickleAtom(v)) }.toMap - import typer.TyperErrorGen._ + // TODO: refactor error handling: fail always throws a TypeError, + // and uses global state (analyzer.lastTreeToTyper) to determine the position for the error def fail(msg: String) = MacroCantExpandIncompatibleMacrosError(msg) def unpickle[T](field: String, clazz: Class[T]): T = { def failField(msg: String) = fail(s"$field $msg") From 338cfff69ea5cbd91f0cbb8f29d690f2069c0a00 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 17 Jul 2014 11:34:16 +0200 Subject: [PATCH 414/826] Reduce Context iface: inline trivial forwarders. The overarching goal is to route all contextual reporting through a single entry point: `context.reporter`. The following commits take baby steps towards this goal. --- .../tools/nsc/typechecker/Implicits.scala | 20 +++++++++---------- .../scala/tools/nsc/typechecker/Infer.scala | 2 +- .../scala/tools/nsc/typechecker/Typers.scala | 14 ++++++------- 3 files changed, 18 insertions(+), 18 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index 98cf9c78305e..965547d83503 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -71,8 +71,8 @@ trait Implicits { typingStack.printTyping(tree, "typing implicit: %s %s".format(tree, context.undetparamsString)) val implicitSearchContext = context.makeImplicit(reportAmbiguous) val result = new ImplicitSearch(tree, pt, isView, implicitSearchContext, pos).bestImplicit - if (result.isFailure && saveAmbiguousDivergent && implicitSearchContext.hasErrors) { - context.updateBuffer(implicitSearchContext.reportBuffer.errors.collect { + if (result.isFailure && saveAmbiguousDivergent && implicitSearchContext.reportBuffer.hasErrors) { + context.reportBuffer ++= (implicitSearchContext.reportBuffer.errors.collect { case dte: DivergentImplicitTypeError => dte case ate: AmbiguousImplicitTypeError => ate }) @@ -99,7 +99,7 @@ trait Implicits { def wrapper(inference: => SearchResult) = wrapper1(inference) val result = wrapper(inferImplicit(tree, pt, reportAmbiguous = true, isView = isView, context = context, saveAmbiguousDivergent = !silent, pos = pos)) if (result.isFailure && !silent) { - val err = context.firstError + val err = context.reportBuffer.firstError val errPos = err.map(_.errPos).getOrElse(pos) val errMsg = err.map(_.errMsg).getOrElse("implicit search has failed. to find out the reason, turn on -Xlog-implicits") onError(errPos, errMsg) @@ -635,7 +635,7 @@ trait Implicits { } case _ => fallback } - context.firstError match { // using match rather than foreach to avoid non local return. + context.reportBuffer.firstError match { // using match rather than foreach to avoid non local return. case Some(err) => log("implicit adapt failed: " + err.errMsg) return fail(err.errMsg) @@ -658,8 +658,8 @@ trait Implicits { } } - if (context.hasErrors) - fail("hasMatchingSymbol reported error: " + context.firstError.get.errMsg) + if (context.reportBuffer.hasErrors) + fail("hasMatchingSymbol reported error: " + context.reportBuffer.firstError.get.errMsg) else if (itree3.isErroneous) fail("error typechecking implicit candidate") else if (isLocalToCallsite && !hasMatchingSymbol(itree2)) @@ -677,7 +677,7 @@ trait Implicits { // #2421: check that we correctly instantiated type parameters outside of the implicit tree: checkBounds(itree3, NoPrefix, NoSymbol, undetParams, targs, "inferred ") - context.firstError match { + context.reportBuffer.firstError match { case Some(err) => return fail("type parameters weren't correctly instantiated outside of the implicit tree: " + err.errMsg) case None => @@ -716,7 +716,7 @@ trait Implicits { case t => t } - context.firstError match { + context.reportBuffer.firstError match { case Some(err) => fail("typing TypeApply reported errors for the implicit tree: " + err.errMsg) case None => @@ -910,7 +910,7 @@ trait Implicits { // the first `DivergentImplicitTypeError` that is being propagated // from a nested implicit search; this one will be // re-issued if this level of the search fails. - DivergentImplicitRecovery(typedFirstPending, firstPending, context.errors) match { + DivergentImplicitRecovery(typedFirstPending, firstPending, context.reportBuffer.errors) match { case sr if sr.isDivergent => Nil case sr if sr.isFailure => rankImplicits(otherPending, acc) case newBest => @@ -1147,7 +1147,7 @@ trait Implicits { try { val tree1 = typedPos(pos.focus)(arg) - context.firstError match { + context.reportBuffer.firstError match { case Some(err) => processMacroExpansionError(err.errPos, err.errMsg) case None => new SearchResult(tree1, EmptyTreeTypeSubstituter, Nil) } diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index cb985ddaf6cd..69ac9ea61e60 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -779,7 +779,7 @@ trait Infer extends Checkable { def applicableExpectingPt(pt: Type): Boolean = { val silent = context.makeSilent(reportAmbiguousErrors = false) val result = newTyper(silent).infer.isApplicable(undetparams, ftpe, argtpes0, pt) - if (silent.hasErrors && !pt.isWildcard) + if (silent.reportBuffer.hasErrors && !pt.isWildcard) applicableExpectingPt(WildcardType) // second try else result diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index ce031e9cd748..0bedaca4eed0 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -697,9 +697,9 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper context.undetparams = context1.undetparams context.savedTypeBounds = context1.savedTypeBounds context.namedApplyBlockInfo = context1.namedApplyBlockInfo - if (context1.hasErrors) { + if (context1.reportBuffer.hasErrors) { stopStats() - SilentTypeError(context1.errors: _*) + SilentTypeError(context1.reportBuffer.errors: _*) } else { // If we have a successful result, emit any warnings it created. context1.flushAndIssueWarnings() @@ -816,14 +816,14 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper } // avoid throwing spurious DivergentImplicit errors - if (context.hasErrors) + if (context.reportBuffer.hasErrors) setError(tree) else withCondConstrTyper(treeInfo.isSelfOrSuperConstrCall(tree))(typer1 => if (original != EmptyTree && pt != WildcardType) ( typer1 silent { tpr => val withImplicitArgs = tpr.applyImplicitArgs(tree) - if (tpr.context.hasErrors) tree // silent will wrap it in SilentTypeError anyway + if (tpr.context.reportBuffer.hasErrors) tree // silent will wrap it in SilentTypeError anyway else tpr.typed(withImplicitArgs, mode, pt) } orElse { _ => @@ -1057,7 +1057,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper val silentContext = context.makeImplicit(context.ambiguousErrors) val res = newTyper(silentContext).typed( new ApplyImplicitView(coercion, List(tree)) setPos tree.pos, mode, pt) - silentContext.firstError match { + silentContext.reportBuffer.firstError match { case Some(err) => context.issue(err) case None => return res } @@ -3229,7 +3229,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper (arg1, arg1.tpe.deconst) }.unzip } - if (context.hasErrors) + if (context.reportBuffer.hasErrors) setError(tree) else { inferMethodAlternative(fun, undetparams, argTpes, pt) @@ -4330,7 +4330,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper c.retyping = true try { val res = newTyper(c).typedArgs(args, mode) - if (c.hasErrors) None else Some(res) + if (c.reportBuffer.hasErrors) None else Some(res) } catch { case ex: CyclicReference => throw ex From 474141f4271d97d082cc8d26c64273eccb5a9ff6 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 17 Jul 2014 11:35:40 +0200 Subject: [PATCH 415/826] Reduce Context iface: inline complex forwarders. --- .../tools/nsc/typechecker/Implicits.scala | 10 +++++----- .../scala/tools/nsc/typechecker/Typers.scala | 20 +++++++++++++------ 2 files changed, 19 insertions(+), 11 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index 965547d83503..e4925b939e1d 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -1359,7 +1359,8 @@ trait Implicits { if (Statistics.canEnable) Statistics.incCounter(inscopeImplicitHits) } if (result.isFailure) { - val previousErrs = context.flushAndReturnBuffer() + val previousErrs = context.reportBuffer.errors + context.reportBuffer.clearAllErrors() val failstart = if (Statistics.canEnable) Statistics.startTimer(oftypeFailNanos) else null val succstart = if (Statistics.canEnable) Statistics.startTimer(oftypeSucceedNanos) else null @@ -1371,7 +1372,7 @@ trait Implicits { result = searchImplicit(implicitsOfExpectedType, isLocalToCallsite = false) if (result.isFailure) { - context.updateBuffer(previousErrs) + context.reportBuffer ++= previousErrs if (Statistics.canEnable) Statistics.stopTimer(oftypeFailNanos, failstart) } else { if (Statistics.canEnable) Statistics.stopTimer(oftypeSucceedNanos, succstart) @@ -1428,9 +1429,8 @@ trait Implicits { // thus, start each type var off with a fresh for every typedImplicit resetTVars() // any previous errors should not affect us now - context.flushBuffer() - - val res = typedImplicit(ii, ptChecked = false, isLocalToCallsite) + context.reportBuffer.clearAllErrors() + val res = typedImplicit(ii, ptChecked = false, isLocalToCallsite) if (res.tree ne EmptyTree) List((res, tvars map (_.constr))) else Nil } diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 0bedaca4eed0..44755c650c0c 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -480,16 +480,20 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper @inline final def typerWithLocalContext[T](c: Context)(f: Typer => T): T = { val res = f(newTyper(c)) - if (c.hasErrors) - context.updateBuffer(c.flushAndReturnBuffer()) + val errors = c.reportBuffer.errors + if (errors.nonEmpty) { + c.reportBuffer.clearAllErrors() + context.reportBuffer ++= errors + } res } @inline final def withSavedContext[T](c: Context)(f: => T) = { - val savedErrors = c.flushAndReturnBuffer() + val savedErrors = c.reportBuffer.errors + c.reportBuffer.clearAllErrors() val res = f - c.updateBuffer(savedErrors) + c.reportBuffer ++= savedErrors res } @@ -702,14 +706,18 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper SilentTypeError(context1.reportBuffer.errors: _*) } else { // If we have a successful result, emit any warnings it created. - context1.flushAndIssueWarnings() + context1.reportBuffer.warnings foreach { + case (pos, msg) => reporter.warning(pos, msg) + } + context1.reportBuffer.clearAllWarnings() SilentResultValue(result) } } else { assert(context.bufferErrors || isPastTyper, "silent mode is not available past typer") withSavedContext(context){ val res = op(this) - val errorsToReport = context.flushAndReturnBuffer() + val errorsToReport = context.reportBuffer.errors + context.reportBuffer.clearAllErrors() if (errorsToReport.isEmpty) SilentResultValue(res) else SilentTypeError(errorsToReport.head) } } From dc955c9c51d22e0dd3264130712e865aba5f47fb Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 17 Jul 2014 11:37:18 +0200 Subject: [PATCH 416/826] Reduce Context iface: encapsulate buffer manipulation. --- .../tools/nsc/typechecker/ContextErrors.scala | 35 +++++++++---------- .../tools/nsc/typechecker/Contexts.scala | 25 +++++++++++++ .../tools/nsc/typechecker/Implicits.scala | 5 +-- .../scala/tools/nsc/typechecker/Typers.scala | 16 +-------- 4 files changed, 44 insertions(+), 37 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala index 028ac46058ca..99cd027df0bc 100644 --- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala @@ -132,6 +132,23 @@ trait ContextErrors { def MacroCantExpandIncompatibleMacrosError(internalMessage: String) = MacroIncompatibleEngineError("macro cannot be expanded, because it was compiled by an incompatible macro engine", internalMessage) + def NoImplicitFoundError(tree: Tree, param: Symbol)(implicit context: Context): Unit = { + def errMsg = { + val paramName = param.name + val paramTp = param.tpe + def evOrParam = ( + if (paramName startsWith nme.EVIDENCE_PARAM_PREFIX) + "evidence parameter of type" + else + s"parameter $paramName:") + paramTp.typeSymbolDirect match { + case ImplicitNotFoundMsg(msg) => msg.format(paramName, paramTp) + case _ => s"could not find implicit value for $evOrParam $paramTp" + } + } + issueNormalTypeError(tree, errMsg) + } + trait TyperContextErrors { self: Typer => @@ -150,24 +167,6 @@ trait ContextErrors { setError(tree) } - def NoImplicitFoundError(tree: Tree, param: Symbol) = { - def errMsg = { - val paramName = param.name - val paramTp = param.tpe - def evOrParam = ( - if (paramName startsWith nme.EVIDENCE_PARAM_PREFIX) - "evidence parameter of type" - else - s"parameter $paramName:" - ) - paramTp.typeSymbolDirect match { - case ImplicitNotFoundMsg(msg) => msg.format(paramName, paramTp) - case _ => s"could not find implicit value for $evOrParam $paramTp" - } - } - issueNormalTypeError(tree, errMsg) - } - def AdaptTypeError(tree: Tree, found: Type, req: Type) = { // SI-3971 unwrapping to the outermost Apply helps prevent confusion with the // error message point. diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 1010ceafe341..56f945623baf 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -1343,6 +1343,31 @@ trait Contexts { self: Analyzer => def hasErrors = errorBuffer.nonEmpty def firstError = errorBuffer.headOption + + // have to pass in context because multiple contexts may share the same ReportBuffer + def reportFirstDivergentError(fun: Tree, param: Symbol, paramTp: Type)(implicit context: Context): Unit = + errors.collectFirst { + case dte: DivergentImplicitTypeError => dte + } match { + case Some(divergent) => + // DivergentImplicit error has higher priority than "no implicit found" + // no need to issue the problem again if we are still in silent mode + if (context.reportErrors) { + context.issue(divergent.withPt(paramTp)) + errorBuffer.retain { + case dte: DivergentImplicitTypeError => false + case _ => true + } + } + case _ => + NoImplicitFoundError(fun, param)(context) + } + + def retainDivergentErrorsExcept(saved: DivergentImplicitTypeError) = + errorBuffer.retain { + case err: DivergentImplicitTypeError => err ne saved + case _ => false + } } class ImportInfo(val tree: Import, val depth: Int) { diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index e4925b939e1d..ed773f01780e 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -861,10 +861,7 @@ trait Implicits { // We don't want errors that occur while checking the implicit info // to influence the check of further infos, but we should retain divergent implicit errors // (except for the one we already squirreled away) - val saved = divergentError.getOrElse(null) - context.reportBuffer.retainErrors { - case err: DivergentImplicitTypeError => err ne saved - } + context.reportBuffer.retainDivergentErrorsExcept(divergentError.getOrElse(null)) } search } diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 44755c650c0c..65dc5148ad89 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -155,21 +155,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper } else { mkArg = gen.mkNamedArg // don't pass the default argument (if any) here, but start emitting named arguments for the following args if (!param.hasDefault && !paramFailed) { - context.reportBuffer.errors.collectFirst { - case dte: DivergentImplicitTypeError => dte - } match { - case Some(divergent) => - // DivergentImplicit error has higher priority than "no implicit found" - // no need to issue the problem again if we are still in silent mode - if (context.reportErrors) { - context.issue(divergent.withPt(paramTp)) - context.reportBuffer.clearErrors { - case dte: DivergentImplicitTypeError => true - } - } - case _ => - NoImplicitFoundError(fun, param) - } + context.reportBuffer.reportFirstDivergentError(fun, param, paramTp)(context) paramFailed = true } /* else { From 1f1c131bb3ba1f63a90aca89153353cba2693fba Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 17 Jul 2014 11:40:27 +0200 Subject: [PATCH 417/826] Reduce Context iface: inline internally. --- .../scala/tools/nsc/typechecker/Contexts.scala | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 56f945623baf..f3c337f633d8 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -389,13 +389,14 @@ trait Contexts { self: Analyzer => // first attempt fails we try with implicits on *and* clean // buffer but that would also flush any pre-tryTwice valid // errors, hence some manual buffer tweaking is necessary. - val errorsToRestore = flushAndReturnBuffer() + val errorsToRestore = reportBuffer.errors + reportBuffer.clearAllErrors() try { withImplicitsDisabled(tryOnce(false)) - if (hasErrors) { + if (reportBuffer.hasErrors) { fallback = true contextMode = savedContextMode - flushBuffer() + reportBuffer.clearAllErrors() tryOnce(true) } } catch { @@ -405,7 +406,7 @@ trait Contexts { self: Analyzer => if (!fallback) tryOnce(true) else () } finally { contextMode = savedContextMode - updateBuffer(errorsToRestore) + reportBuffer ++= errorsToRestore } } else tryOnce(true) @@ -453,7 +454,7 @@ trait Contexts { self: Analyzer => @inline final def inSilentMode(expr: => Boolean): Boolean = { withMode() { // withMode with no arguments to restore the mode mutated by `setBufferErrors`. setBufferErrors() - try expr && !hasErrors + try expr && !reportBuffer.hasErrors finally reportBuffer.clearAll() } } From 03baff77059df0632e9acb9fedac3702b2687924 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 17 Jul 2014 11:42:36 +0200 Subject: [PATCH 418/826] Reduce Context iface: make contextMode mutators private. This allows local reasoning about these bits, giving some more confidence for the refactoring that's underway. --- .../scala/tools/nsc/typechecker/Contexts.scala | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index f3c337f633d8..6adf7ba5cc88 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -345,12 +345,12 @@ trait Contexts { self: Analyzer => def reportErrors = this(ReportErrors) def bufferErrors = this(BufferErrors) def ambiguousErrors = this(AmbiguousErrors) - def throwErrors = contextMode.inNone(ReportErrors | BufferErrors) + private def throwErrors = contextMode.inNone(ReportErrors | BufferErrors) - def setReportErrors(): Unit = set(enable = ReportErrors | AmbiguousErrors, disable = BufferErrors) - def setBufferErrors(): Unit = set(enable = BufferErrors, disable = ReportErrors | AmbiguousErrors) - def setThrowErrors(): Unit = this(ReportErrors | AmbiguousErrors | BufferErrors) = false - def setAmbiguousErrors(report: Boolean): Unit = this(AmbiguousErrors) = report + private def setReportErrors(): Unit = set(enable = ReportErrors | AmbiguousErrors, disable = BufferErrors) + private def setBufferErrors(): Unit = set(enable = BufferErrors, disable = ReportErrors | AmbiguousErrors) + private def setThrowErrors(): Unit = this(ReportErrors | AmbiguousErrors | BufferErrors) = false + private def setAmbiguousErrors(report: Boolean): Unit = this(AmbiguousErrors) = report /** Append the given errors to the report buffer */ def updateBuffer(errors: Traversable[AbsTypeError]) = reportBuffer ++= errors From 5e62c59aad9dabb3b07e2330d2f8b937f48b93e8 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 17 Jul 2014 11:44:43 +0200 Subject: [PATCH 419/826] Reduce Context iface: remove dead code. --- .../tools/nsc/typechecker/Contexts.scala | 37 ------------------- 1 file changed, 37 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 6adf7ba5cc88..8b53e8eeacd4 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -331,16 +331,6 @@ trait Contexts { self: Analyzer => private var _reportBuffer: ReportBuffer = new ReportBuffer /** A buffer for errors and warnings, used with `this.bufferErrors == true` */ def reportBuffer = _reportBuffer - /** Discard the current report buffer, and replace with an empty one */ - def useFreshReportBuffer() = _reportBuffer = new ReportBuffer - /** Discard the current report buffer, and replace with `other` */ - def restoreReportBuffer(other: ReportBuffer) = _reportBuffer = other - - /** The first error, if any, in the report buffer */ - def firstError: Option[AbsTypeError] = reportBuffer.firstError - def errors: Seq[AbsTypeError] = reportBuffer.errors - /** Does the report buffer contain any errors? */ - def hasErrors = reportBuffer.hasErrors def reportErrors = this(ReportErrors) def bufferErrors = this(BufferErrors) @@ -352,25 +342,6 @@ trait Contexts { self: Analyzer => private def setThrowErrors(): Unit = this(ReportErrors | AmbiguousErrors | BufferErrors) = false private def setAmbiguousErrors(report: Boolean): Unit = this(AmbiguousErrors) = report - /** Append the given errors to the report buffer */ - def updateBuffer(errors: Traversable[AbsTypeError]) = reportBuffer ++= errors - /** Clear all errors from the report buffer */ - def flushBuffer() { reportBuffer.clearAllErrors() } - /** Return and clear all errors from the report buffer */ - def flushAndReturnBuffer(): immutable.Seq[AbsTypeError] = { - val current = reportBuffer.errors - reportBuffer.clearAllErrors() - current - } - - /** Issue and clear all warnings from the report buffer */ - def flushAndIssueWarnings() { - reportBuffer.warnings foreach { - case (pos, msg) => reporter.warning(pos, msg) - } - reportBuffer.clearAllWarnings() - } - /** Try inference twice, once without views and once with views, * unless views are already disabled. @@ -1329,14 +1300,6 @@ trait Contexts { self: Analyzer => errorBuffer.clear() this } - def clearErrors(removeF: PartialFunction[AbsTypeError, Boolean]): this.type = { - errorBuffer.retain(!PartialFunction.cond(_)(removeF)) - this - } - def retainErrors(leaveF: PartialFunction[AbsTypeError, Boolean]): this.type = { - errorBuffer.retain(PartialFunction.cond(_)(leaveF)) - this - } def clearAllWarnings(): this.type = { warningBuffer.clear() this From c6bee6437a626c93be3951ee0437adce8c88e96c Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Wed, 9 Jul 2014 17:15:40 +0200 Subject: [PATCH 420/826] Untangle reporting of ambiguous errors. Now that all reporting mode manipulators are private to Context, let's untangle this logic: - every `setReportErrors` gets a corresponding `setAmbiguousErrors(true)` - every `setBufferErrors` gets a corresponding `setAmbiguousErrors(false)` - every `setThrowErrors` gets a corresponding `setAmbiguousErrors(false)` `ambiguousErrors` means that ambiguity errors *must* be reported, even when in silent mode. When it's false, they are *not* reported, but they are buffered when the context reporter is buffering. TODO: this seems a bit dubious, but this is what happens now. Let's see if we can simplify this once the refactoring is complete. Again, the end goal is a strategy-based approach to reporting, where the reporting mode is captured in the reporter being used, with as little mutation as possible to capture more invariants (would like to stop throwing TypeError eventually and only have two reporters: buffering reporter, regular reporter) --- .../scala/tools/nsc/typechecker/Contexts.scala | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 8b53e8eeacd4..f5f949456256 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -317,7 +317,7 @@ trait Contexts { self: Analyzer => */ def savingUndeterminedTypeParams[A](reportAmbiguous: Boolean = ambiguousErrors)(body: => A): A = { withMode() { - this(AmbiguousErrors) = reportAmbiguous + setAmbiguousErrors(reportAmbiguous) val saved = extractUndetparams() try body finally undetparams = saved @@ -337,9 +337,9 @@ trait Contexts { self: Analyzer => def ambiguousErrors = this(AmbiguousErrors) private def throwErrors = contextMode.inNone(ReportErrors | BufferErrors) - private def setReportErrors(): Unit = set(enable = ReportErrors | AmbiguousErrors, disable = BufferErrors) - private def setBufferErrors(): Unit = set(enable = BufferErrors, disable = ReportErrors | AmbiguousErrors) - private def setThrowErrors(): Unit = this(ReportErrors | AmbiguousErrors | BufferErrors) = false + private def setReportErrors(): Unit = set(enable = ReportErrors, disable = BufferErrors) + private def setBufferErrors(): Unit = set(enable = BufferErrors, disable = ReportErrors) + private def setThrowErrors(): Unit = this(ReportErrors | BufferErrors) = false private def setAmbiguousErrors(report: Boolean): Unit = this(AmbiguousErrors) = report @@ -354,6 +354,7 @@ trait Contexts { self: Analyzer => val savedContextMode = contextMode var fallback = false setBufferErrors() + setAmbiguousErrors(false) // We cache the current buffer because it is impossible to // distinguish errors that occurred before entering tryTwice // and our first attempt in 'withImplicitsDisabled'. If the @@ -425,6 +426,7 @@ trait Contexts { self: Analyzer => @inline final def inSilentMode(expr: => Boolean): Boolean = { withMode() { // withMode with no arguments to restore the mode mutated by `setBufferErrors`. setBufferErrors() + setAmbiguousErrors(false) try expr && !reportBuffer.hasErrors finally reportBuffer.clearAll() } @@ -492,6 +494,7 @@ trait Contexts { self: Analyzer => /** Use reporter (possibly buffered) for errors/warnings and enable implicit conversion **/ def initRootContext(): Unit = { setReportErrors() + setAmbiguousErrors(true) this(EnrichmentEnabled | ImplicitsEnabled) = true } @@ -500,6 +503,7 @@ trait Contexts { self: Analyzer => */ def initRootContextPostTyper(): Unit = { setThrowErrors() + setAmbiguousErrors(false) this(EnrichmentEnabled | ImplicitsEnabled) = false } @@ -525,6 +529,7 @@ trait Contexts { self: Analyzer => def makeNonSilent(newtree: Tree): Context = { val c = make(newtree) c.setReportErrors() + c.setAmbiguousErrors(true) c } From 43da1dbbe99e8bdb98d9e08b8e3a255dd4af6902 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 17 Jul 2014 11:48:49 +0200 Subject: [PATCH 421/826] Introduce `AbsAmbiguousTypeError`. It's the superclass for type errors that should be issued with `issueAmbiguousError`. TODO: enforce this in `issues` itself using a type test, remove the static overload. --- .../tools/nsc/typechecker/ContextErrors.scala | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala index 99cd027df0bc..20e462bbce8f 100644 --- a/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala @@ -27,6 +27,16 @@ trait ContextErrors { override def toString() = "[Type error at:" + errPos + "] " + errMsg } + abstract class AbsAmbiguousTypeError extends AbsTypeError + + case class AmbiguousTypeError(errPos: Position, errMsg: String) + extends AbsAmbiguousTypeError + + case class AmbiguousImplicitTypeError(underlyingTree: Tree, errMsg: String) + extends AbsAmbiguousTypeError { + def errPos = underlyingTree.pos + } + sealed abstract class TreeTypeError extends AbsTypeError { def underlyingTree: Tree def errPos = underlyingTree.pos @@ -38,9 +48,6 @@ trait ContextErrors { case class AccessTypeError(underlyingTree: Tree, errMsg: String) extends TreeTypeError - case class AmbiguousTypeError(errPos: Position, errMsg: String) - extends AbsTypeError - case class SymbolTypeError(underlyingSym: Symbol, errMsg: String) extends AbsTypeError { @@ -75,8 +82,6 @@ trait ContextErrors { s"diverging implicit expansion for type ${pt}\nstarting with ${sym.fullLocationString}" } - case class AmbiguousImplicitTypeError(underlyingTree: Tree, errMsg: String) - extends TreeTypeError case class PosAndMsgTypeError(errPos: Position, errMsg: String) extends AbsTypeError From 064bc5eb25094f0d6de2aa8990466fed29d3c095 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 17 Jul 2014 11:49:37 +0200 Subject: [PATCH 422/826] Remove `def error(pos: Position, err: Throwable)` The overload was used only once. --- src/compiler/scala/tools/nsc/typechecker/Contexts.scala | 5 ----- .../scala/tools/nsc/typechecker/TypeDiagnostics.scala | 2 +- 2 files changed, 1 insertion(+), 6 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index f5f949456256..e7ab9dc94e72 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -604,11 +604,6 @@ trait Contexts { self: Analyzer => /** Issue/buffer/throw the given implicit ambiguity error according to the current mode for error reporting. */ private[typechecker] def issueAmbiguousError(err: AbsTypeError) = issueCommon(err, ambiguousErrors) - /** Issue/throw the given `err` according to the current mode for error reporting. */ - def error(pos: Position, err: Throwable) = - if (reportErrors) unitError(pos, addDiagString(err.getMessage())) - else throw err - /** Issue/throw the given error message according to the current mode for error reporting. */ def error(pos: Position, msg: String) = { val msg1 = addDiagString(msg) diff --git a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala index fbea69db5a89..89b064e7c16f 100644 --- a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala +++ b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala @@ -629,7 +629,7 @@ trait TypeDiagnostics { throw new FatalError("cannot redefine root "+sym) } case _ => - context0.error(ex.pos, ex) + context0.error(ex.pos, ex.msg) } } } From cdee8350288edb1054bfc841f81bd21b9e6a0323 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 17 Jul 2014 12:14:46 +0200 Subject: [PATCH 423/826] Configure `checking` mode in `rootContext`. This is used by the tree checkers. --- .../tools/nsc/typechecker/Contexts.scala | 29 +++++++------------ .../tools/nsc/typechecker/TreeCheckers.scala | 3 +- 2 files changed, 11 insertions(+), 21 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index e7ab9dc94e72..746483740966 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -98,7 +98,7 @@ trait Contexts { self: Analyzer => } - def rootContext(unit: CompilationUnit, tree: Tree = EmptyTree): Context = { + def rootContext(unit: CompilationUnit, tree: Tree = EmptyTree, throwing: Boolean = false, checking: Boolean = false): Context = { val rootImportsContext = (startContext /: rootImports(unit))((c, sym) => c.make(gen.mkWildcardImport(sym))) // there must be a scala.xml package when xml literals were parsed in this unit @@ -113,16 +113,13 @@ trait Contexts { self: Analyzer => else rootImportsContext.make(gen.mkImport(ScalaXmlPackage, nme.TopScope, nme.dollarScope)) val c = contextWithXML.make(tree, unit = unit) - c.initRootContext() - c - } - def rootContextPostTyper(unit: CompilationUnit, tree: Tree = EmptyTree): Context = { - val c = rootContext(unit, tree) - c.initRootContextPostTyper() + c.initRootContext(throwing, checking) c } + def rootContextPostTyper(unit: CompilationUnit, tree: Tree = EmptyTree): Context = + rootContext(unit, tree, throwing = true) def resetContexts() { startContext.enclosingContextChain foreach { context => @@ -492,19 +489,13 @@ trait Contexts { self: Analyzer => } /** Use reporter (possibly buffered) for errors/warnings and enable implicit conversion **/ - def initRootContext(): Unit = { - setReportErrors() - setAmbiguousErrors(true) - this(EnrichmentEnabled | ImplicitsEnabled) = true - } + def initRootContext(throwing: Boolean = false, checking: Boolean = false): Unit = { + if (checking) this.checking = true + else if (throwing) setThrowErrors() + else setReportErrors() - /** Disable implicit conversion/enrichment, throw TypeError on error. - * TODO: can we phase out TypeError and uniformly rely on reporter? - */ - def initRootContextPostTyper(): Unit = { - setThrowErrors() - setAmbiguousErrors(false) - this(EnrichmentEnabled | ImplicitsEnabled) = false + setAmbiguousErrors(!throwing) + this(EnrichmentEnabled | ImplicitsEnabled) = !throwing } def make(tree: Tree, owner: Symbol, scope: Scope): Context = diff --git a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala index 399a4ca8d50c..743bbe53bd31 100644 --- a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala @@ -208,8 +208,7 @@ abstract class TreeCheckers extends Analyzer { } def check(unit: CompilationUnit) { informProgress("checking "+unit) - val context = rootContext(unit) - context.checking = true + val context = rootContext(unit, checking = true) tpeOfTree.clear() SymbolTracker.check(phase, unit) val checker = new TreeChecker(context) From bde623925d011841f222891050c5fdb08f3bb251 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Thu, 17 Jul 2014 10:04:20 -0700 Subject: [PATCH 424/826] SI-8525 Multichoice help Enables -Xlint:help and -language:help. The Settings API makes it difficult to innovate. --- .../scala/tools/nsc/CompilerCommand.scala | 10 +++++++++- .../tools/nsc/settings/MutableSettings.scala | 17 +++++++++++------ .../tools/nsc/settings/ScalaSettings.scala | 7 +++++-- .../scala/tools/nsc/settings/Warnings.scala | 18 +++++++++++++----- 4 files changed, 38 insertions(+), 14 deletions(-) diff --git a/src/compiler/scala/tools/nsc/CompilerCommand.scala b/src/compiler/scala/tools/nsc/CompilerCommand.scala index a1d0d52dcf0c..95f7a709808f 100644 --- a/src/compiler/scala/tools/nsc/CompilerCommand.scala +++ b/src/compiler/scala/tools/nsc/CompilerCommand.scala @@ -103,7 +103,15 @@ class CompilerCommand(arguments: List[String], val settings: Settings) { val components = global.phaseNames // global.phaseDescriptors // one initializes s"Phase graph of ${components.size} components output to ${genPhaseGraph.value}*.dot." } - else "" + // would be nicer if we could ask all the options for their helpful messages + else { + val sb = new StringBuilder + allSettings foreach { + case s: MultiChoiceSetting if s.isHelping => sb append s.help append "\n" + case _ => + } + sb.toString + } } /** diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala index 0dd4ae0b3b04..8c69b49b98cc 100644 --- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala @@ -201,7 +201,7 @@ class MutableSettings(val errorFn: String => Unit) } // a wrapper for all Setting creators to keep our list up to date - private def add[T <: Setting](s: T): T = { + private[nsc] def add[T <: Setting](s: T): T = { allSettings += s s } @@ -552,7 +552,7 @@ class MutableSettings(val errorFn: String => Unit) } /** A setting that receives any combination of enumerated values, - * including "_" to mean all values. + * including "_" to mean all values and "help" for verbose info. * In non-colonated mode, stops consuming args at the first * non-value, instead of at the next option, as for a multi-string. */ @@ -562,16 +562,18 @@ class MutableSettings(val errorFn: String => Unit) descr: String, override val choices: List[String], val default: () => Unit - ) extends MultiStringSetting(name, arg, s"$descr${ choices.mkString(": ", ",", ".") }") { + ) extends MultiStringSetting(name, s"_,$arg,-$arg", s"$descr: `_' for all, `$name:help' to list") { - def badChoice(s: String, n: String) = errorFn(s"'$s' is not a valid choice for '$name'") - def choosing = choices.nonEmpty - def isChoice(s: String) = (s == "_") || (choices contains (s stripPrefix "-")) + private def badChoice(s: String, n: String) = errorFn(s"'$s' is not a valid choice for '$name'") + private def choosing = choices.nonEmpty + private def isChoice(s: String) = (s == "_") || (choices contains (s stripPrefix "-")) + private var sawHelp = false override protected def tts(args: List[String], halting: Boolean) = { val added = collection.mutable.ListBuffer.empty[String] def tryArg(arg: String) = arg match { case "_" if choosing => default() + case "help" if choosing => sawHelp = true case s if !choosing || isChoice(s) => added += s case s => badChoice(s, name) } @@ -586,6 +588,9 @@ class MutableSettings(val errorFn: String => Unit) else value = added.toList // update all new settings at once Some(rest) } + + def isHelping: Boolean = sawHelp + def help: String = s"$descr${ choices.mkString(":\n", " \n", "\n") }" } /** A setting that accumulates all strings supplied to it, diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala index d22dcacad67e..6675ad96e6d4 100644 --- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala @@ -44,8 +44,11 @@ trait ScalaSettings extends AbsScalaSettings /** If any of these settings is enabled, the compiler should print a message and exit. */ def infoSettings = List[Setting](version, help, Xhelp, Yhelp, showPlugins, showPhases, genPhaseGraph) + /** Any -multichoice:help? Nicer if any option could report that it had help to offer. */ + private def multihelp = allSettings exists { case s: MultiChoiceSetting => s.isHelping case _ => false } + /** Is an info setting set? */ - def isInfo = infoSettings exists (_.isSetByUser) + def isInfo = (infoSettings exists (_.isSetByUser)) || multihelp /** Disable a setting */ def disable(s: Setting) = allSettings -= s @@ -68,7 +71,7 @@ trait ScalaSettings extends AbsScalaSettings // The two requirements: delay error checking until you have symbols, and let compiler command build option-specific help. val language = { val features = List("dynamics", "postfixOps", "reflectiveCalls", "implicitConversions", "higherKinds", "existentials", "experimental.macros") - MultiChoiceSetting("-language", "feature", "Enable one or more language features", features) + MultiChoiceSetting("-language", "feature", "Enable or disable language features", features) } /* diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala index 0b9ad8004196..3accd9fdaa9d 100644 --- a/src/compiler/scala/tools/nsc/settings/Warnings.scala +++ b/src/compiler/scala/tools/nsc/settings/Warnings.scala @@ -108,14 +108,19 @@ trait Warnings { // The Xlint warning group. private val xlint = new BooleanSetting("-Zunused", "True if -Xlint or -Xlint:_") // On -Xlint or -Xlint:_, set xlint, otherwise set the lint warning unless already set true - val lint = - MultiChoiceSetting( + val lint = { + val d = "Enable or disable specific warnings" + val s = new MultiChoiceSetting( name = "-Xlint", - helpArg = "warning", - descr = "Enable recommended additional warnings", + arg = "warning", + descr = d, choices = (lintWarnings map (_.name)).sorted, default = () => xlint.value = true - ) withPostSetHook { x => + ) { + def helpline(n: String) = lintWarnings.find(_.name == n).map(w => f" ${w.name}%-25s ${w.helpDescription}%n") + override def help = s"$d${ choices flatMap (helpline(_)) mkString (":\n", "", "\n") }" + } + val t = s withPostSetHook { x => val Neg = "-" def setPolitely(b: BooleanSetting, v: Boolean) = if (!b.isSetByUser || !b) b.value = v def set(w: String, v: Boolean) = lintWarnings find (_.name == w) foreach (setPolitely(_, v)) @@ -125,6 +130,9 @@ trait Warnings { } propagate(x.value) } + add(t) + t + } // Lint warnings that are currently -Y, but deprecated in that usage @deprecated("Use warnAdaptedArgs", since="2.11.2") From 68560dd80d99f031bdf419f08463abeb83e47b3c Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Fri, 18 Jul 2014 00:19:01 -0700 Subject: [PATCH 425/826] SI-8525 MultiChoice takes a helper function Clean-up code review comments. MultiChoice takes a helper function for outputting help text. --- .../scala/tools/nsc/CompilerCommand.scala | 2 +- .../tools/nsc/settings/AbsScalaSettings.scala | 2 +- .../tools/nsc/settings/MutableSettings.scala | 13 +++++++---- .../tools/nsc/settings/ScalaSettings.scala | 23 +++++++++++++++++-- .../scala/tools/nsc/settings/Warnings.scala | 20 ++++++++-------- 5 files changed, 40 insertions(+), 20 deletions(-) diff --git a/src/compiler/scala/tools/nsc/CompilerCommand.scala b/src/compiler/scala/tools/nsc/CompilerCommand.scala index 95f7a709808f..3ded4563789d 100644 --- a/src/compiler/scala/tools/nsc/CompilerCommand.scala +++ b/src/compiler/scala/tools/nsc/CompilerCommand.scala @@ -107,7 +107,7 @@ class CompilerCommand(arguments: List[String], val settings: Settings) { else { val sb = new StringBuilder allSettings foreach { - case s: MultiChoiceSetting if s.isHelping => sb append s.help append "\n" + case s: MultiChoiceSetting if s.isHelping => sb append s.help case _ => } sb.toString diff --git a/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala index ef9695a5949f..c73e7ce00e7a 100644 --- a/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala @@ -29,7 +29,7 @@ trait AbsScalaSettings { def ChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: String): ChoiceSetting def IntSetting(name: String, descr: String, default: Int, range: Option[(Int, Int)], parser: String => Option[Int]): IntSetting def MultiStringSetting(name: String, helpArg: String, descr: String): MultiStringSetting - def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: () => Unit): MultiChoiceSetting + def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: () => Unit)(helper: MultiChoiceSetting => String): MultiChoiceSetting def OutputSetting(outputDirs: OutputDirs, default: String): OutputSetting def PathSetting(name: String, descr: String, default: String): PathSetting def PhasesSetting(name: String, descr: String, default: String): PhasesSetting diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala index 8c69b49b98cc..3f41ede3ad1c 100644 --- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala @@ -201,7 +201,7 @@ class MutableSettings(val errorFn: String => Unit) } // a wrapper for all Setting creators to keep our list up to date - private[nsc] def add[T <: Setting](s: T): T = { + private def add[T <: Setting](s: T): T = { allSettings += s s } @@ -211,8 +211,10 @@ class MutableSettings(val errorFn: String => Unit) add(new ChoiceSetting(name, helpArg, descr, choices, default)) def IntSetting(name: String, descr: String, default: Int, range: Option[(Int, Int)], parser: String => Option[Int]) = add(new IntSetting(name, descr, default, range, parser)) def MultiStringSetting(name: String, arg: String, descr: String) = add(new MultiStringSetting(name, arg, descr)) - def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: () => Unit = () => ()) = - add(new MultiChoiceSetting(name, helpArg, descr, choices, default)) + def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: () => Unit = () => ())( + helper: MultiChoiceSetting => String = _ => choices.mkString(f"$descr:%n", f"%n ", f"%n") + ) = + add(new MultiChoiceSetting(name, helpArg, descr, choices, default, helper)) def OutputSetting(outputDirs: OutputDirs, default: String) = add(new OutputSetting(outputDirs, default)) def PhasesSetting(name: String, descr: String, default: String = "") = add(new PhasesSetting(name, descr, default)) def StringSetting(name: String, arg: String, descr: String, default: String) = add(new StringSetting(name, arg, descr, default)) @@ -561,7 +563,8 @@ class MutableSettings(val errorFn: String => Unit) arg: String, descr: String, override val choices: List[String], - val default: () => Unit + val default: () => Unit, + helper: MultiChoiceSetting => String ) extends MultiStringSetting(name, s"_,$arg,-$arg", s"$descr: `_' for all, `$name:help' to list") { private def badChoice(s: String, n: String) = errorFn(s"'$s' is not a valid choice for '$name'") @@ -590,7 +593,7 @@ class MutableSettings(val errorFn: String => Unit) } def isHelping: Boolean = sawHelp - def help: String = s"$descr${ choices.mkString(":\n", " \n", "\n") }" + def help: String = helper(this) } /** A setting that accumulates all strings supplied to it, diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala index 6675ad96e6d4..5c3eadbd608a 100644 --- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala @@ -70,8 +70,27 @@ trait ScalaSettings extends AbsScalaSettings // Would be nice to build this dynamically from scala.languageFeature. // The two requirements: delay error checking until you have symbols, and let compiler command build option-specific help. val language = { - val features = List("dynamics", "postfixOps", "reflectiveCalls", "implicitConversions", "higherKinds", "existentials", "experimental.macros") - MultiChoiceSetting("-language", "feature", "Enable or disable language features", features) + val features = List( + "dynamics" -> "Allow direct or indirect subclasses of scala.Dynamic", + "postfixOps" -> "Allow postfix operator notation, such as `1 to 10 toList'", + "reflectiveCalls" -> "Allow reflective access to members of structural types", + "implicitConversions" -> "Allow definition of implicit functions called views", + "higherKinds" -> "Allow higher-kinded types", // "Ask Adriaan, but if you have to ask..." + "existentials" -> "Existential types (besides wildcard types) can be written and inferred", + "experimental.macros" -> "Allow macro defintion (besides implementation and application)" + ) + val description = "Enable or disable language features" + MultiChoiceSetting( + name = "-language", + helpArg = "feature", + descr = description, + choices = features map (_._1) + ) { s => + val helpline: ((String, String)) => String = { + case (name, text) => f" $name%-25s $text%n" + } + features map helpline mkString (f"$description:%n", "", f"%n") + } } /* diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala index 3accd9fdaa9d..9989d1d1880e 100644 --- a/src/compiler/scala/tools/nsc/settings/Warnings.scala +++ b/src/compiler/scala/tools/nsc/settings/Warnings.scala @@ -109,18 +109,18 @@ trait Warnings { private val xlint = new BooleanSetting("-Zunused", "True if -Xlint or -Xlint:_") // On -Xlint or -Xlint:_, set xlint, otherwise set the lint warning unless already set true val lint = { - val d = "Enable or disable specific warnings" - val s = new MultiChoiceSetting( + val description = "Enable or disable specific warnings" + val choices = (lintWarnings map (_.name)).sorted + MultiChoiceSetting( name = "-Xlint", - arg = "warning", - descr = d, - choices = (lintWarnings map (_.name)).sorted, + helpArg = "warning", + descr = description, + choices = choices, default = () => xlint.value = true - ) { + ) { s => def helpline(n: String) = lintWarnings.find(_.name == n).map(w => f" ${w.name}%-25s ${w.helpDescription}%n") - override def help = s"$d${ choices flatMap (helpline(_)) mkString (":\n", "", "\n") }" - } - val t = s withPostSetHook { x => + choices flatMap (helpline(_)) mkString (f"$description:%n", "", f"%n") + } withPostSetHook { x => val Neg = "-" def setPolitely(b: BooleanSetting, v: Boolean) = if (!b.isSetByUser || !b) b.value = v def set(w: String, v: Boolean) = lintWarnings find (_.name == w) foreach (setPolitely(_, v)) @@ -130,8 +130,6 @@ trait Warnings { } propagate(x.value) } - add(t) - t } // Lint warnings that are currently -Y, but deprecated in that usage From ff7c467f7d985086e351cfd8ab90d28724d393f4 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Fri, 18 Jul 2014 11:03:00 +0200 Subject: [PATCH 426/826] repl depends on jline-2.12 --- src/eclipse/repl/.classpath | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/eclipse/repl/.classpath b/src/eclipse/repl/.classpath index 8fed2a3f616d..8ff9aabfbf0b 100644 --- a/src/eclipse/repl/.classpath +++ b/src/eclipse/repl/.classpath @@ -2,10 +2,10 @@ - + + - From f0fdcc010966030d55c297d5725adaaddfe7d20d Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Fri, 18 Jul 2014 14:34:46 +0200 Subject: [PATCH 427/826] Clarify that ThrowErrors is the default --- .../scala/tools/nsc/typechecker/Contexts.scala | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 746483740966..9a6647a83a7c 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -329,14 +329,14 @@ trait Contexts { self: Analyzer => /** A buffer for errors and warnings, used with `this.bufferErrors == true` */ def reportBuffer = _reportBuffer - def reportErrors = this(ReportErrors) + def reportErrors = contextMode.inNone(ThrowErrors | BufferErrors) def bufferErrors = this(BufferErrors) def ambiguousErrors = this(AmbiguousErrors) - private def throwErrors = contextMode.inNone(ReportErrors | BufferErrors) + private def throwErrors = this(ThrowErrors) - private def setReportErrors(): Unit = set(enable = ReportErrors, disable = BufferErrors) - private def setBufferErrors(): Unit = set(enable = BufferErrors, disable = ReportErrors) - private def setThrowErrors(): Unit = this(ReportErrors | BufferErrors) = false + private def setReportErrors(): Unit = set(disable = BufferErrors | ThrowErrors) + private def setBufferErrors(): Unit = set(enable = BufferErrors, disable = ThrowErrors) + private def setThrowErrors(): Unit = set(enable = ThrowErrors, disable = BufferErrors) private def setAmbiguousErrors(report: Boolean): Unit = this(AmbiguousErrors) = report @@ -1417,7 +1417,7 @@ object ContextMode { def apply(bits: Int): ContextMode = new ContextMode(bits) final val NOmode: ContextMode = 0 - final val ReportErrors: ContextMode = 1 << 0 + final val ThrowErrors: ContextMode = 1 << 0 final val BufferErrors: ContextMode = 1 << 1 final val AmbiguousErrors: ContextMode = 1 << 2 @@ -1479,10 +1479,10 @@ object ContextMode { PatternAlternative | StarPatterns | SuperInit | SecondTry | ReturnExpr | TypeConstructorAllowed ) - final val DefaultMode: ContextMode = MacrosEnabled + final val DefaultMode: ContextMode = MacrosEnabled | ThrowErrors private val contextModeNameMap = Map( - ReportErrors -> "ReportErrors", + ThrowErrors -> "ReportErrors", BufferErrors -> "BufferErrors", AmbiguousErrors -> "AmbiguousErrors", ConstructorSuffix -> "ConstructorSuffix", From 725c5c907ba9ecdec4ee343bd0aa0ff438b4c20c Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 17 Jul 2014 12:29:49 +0200 Subject: [PATCH 428/826] Encapsulate reporting mode as class of reportBuffer. Reporting mode used to be governed by contextMode. This logic is left in place by this commit, and the consistency of the new and the old is checked. Will be removed in follow-up commit. The main difference is that we no longer throw TypeErrors in buffering mode. There was one instance of context.error in implicit search the exploited the fact that implicit search runs in buffering (silent) mode and thus calls to error(pos,msg) used to throw new TypeError(pos, msg) -- made this explicit, and removed throwing behavior from the buffering context reporter. --- .../tools/nsc/typechecker/Contexts.scala | 145 ++++++++++++------ .../tools/nsc/typechecker/Implicits.scala | 11 +- test/files/neg/macro-basic-mamdmi.check | 10 +- 3 files changed, 113 insertions(+), 53 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 9a6647a83a7c..37eff40dd8db 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -9,6 +9,7 @@ package typechecker import scala.collection.{ immutable, mutable } import scala.annotation.tailrec import scala.reflect.internal.util.shortClassOfInstance +import scala.tools.nsc.reporters.Reporter /** * @author Martin Odersky @@ -325,9 +326,22 @@ trait Contexts { self: Analyzer => // Error reporting policies and buffer. // - private var _reportBuffer: ReportBuffer = new ReportBuffer + // TODO: start out with a regular reporter? + private var _reportBuffer: ContextReporter = new ThrowingReporter + /** A buffer for errors and warnings, used with `this.bufferErrors == true` */ - def reportBuffer = _reportBuffer + def reportBuffer = { + assert( + (bufferErrors == _reportBuffer.isInstanceOf[BufferingReporter]) + && (throwErrors == _reportBuffer.isInstanceOf[ThrowingReporter]) + && (checking == _reportBuffer.isInstanceOf[CheckingReporter]) + && (reportErrors != (_reportBuffer.isInstanceOf[BufferingReporter] + || _reportBuffer.isInstanceOf[ThrowingReporter] + || _reportBuffer.isInstanceOf[CheckingReporter])), + s"INCONSISTENCY $contextMode != ${_reportBuffer.getClass}") + + _reportBuffer + } def reportErrors = contextMode.inNone(ThrowErrors | BufferErrors) def bufferErrors = this(BufferErrors) @@ -349,7 +363,9 @@ trait Contexts { self: Analyzer => def apply(): Unit = if (implicitsEnabled) { val savedContextMode = contextMode + val savedReporter = _reportBuffer var fallback = false + _reportBuffer = (new BufferingReporter).sharingBuffersWith(reportBuffer) setBufferErrors() setAmbiguousErrors(false) // We cache the current buffer because it is impossible to @@ -365,6 +381,7 @@ trait Contexts { self: Analyzer => if (reportBuffer.hasErrors) { fallback = true contextMode = savedContextMode + _reportBuffer = savedReporter reportBuffer.clearAllErrors() tryOnce(true) } @@ -372,9 +389,11 @@ trait Contexts { self: Analyzer => case ex: CyclicReference => throw ex case ex: TypeError => // recoverable cyclic references contextMode = savedContextMode + _reportBuffer = savedReporter if (!fallback) tryOnce(true) else () } finally { contextMode = savedContextMode + _reportBuffer = savedReporter reportBuffer ++= errorsToRestore } } @@ -421,11 +440,16 @@ trait Contexts { self: Analyzer => /** @return true if the `expr` evaluates to true within a silent Context that incurs no errors */ @inline final def inSilentMode(expr: => Boolean): Boolean = { + val savedReporter = _reportBuffer withMode() { // withMode with no arguments to restore the mode mutated by `setBufferErrors`. + _reportBuffer = (new BufferingReporter).sharingBuffersWith(reportBuffer) setBufferErrors() setAmbiguousErrors(false) try expr && !reportBuffer.hasErrors - finally reportBuffer.clearAll() + finally { + _reportBuffer = savedReporter + _reportBuffer.clearAll() // TODO: ??? + } } } @@ -473,7 +497,7 @@ trait Contexts { self: Analyzer => c.diagUsedDefaults = diagUsedDefaults c.openImplicits = openImplicits c.contextMode = contextMode // note: ConstructorSuffix, a bit within `mode`, is conditionally overwritten below. - c._reportBuffer = reportBuffer + c._reportBuffer = _reportBuffer // Fields that may take on a different value in the child c.prefix = prefixInChild @@ -490,9 +514,10 @@ trait Contexts { self: Analyzer => /** Use reporter (possibly buffered) for errors/warnings and enable implicit conversion **/ def initRootContext(throwing: Boolean = false, checking: Boolean = false): Unit = { - if (checking) this.checking = true - else if (throwing) setThrowErrors() - else setReportErrors() + _reportBuffer = + if (checking) {this.checking = true ; new CheckingReporter} + else if (throwing) {setThrowErrors(); new ThrowingReporter} + else {setReportErrors() ; new ContextReporter} // TODO: this is likely redundant setAmbiguousErrors(!throwing) this(EnrichmentEnabled | ImplicitsEnabled) = !throwing @@ -500,7 +525,7 @@ trait Contexts { self: Analyzer => def make(tree: Tree, owner: Symbol, scope: Scope): Context = // TODO SI-7345 Moving this optimization into the main overload of `make` causes all tests to fail. - // even if it is extened to check that `unit == this.unit`. Why is this? + // even if it is extended to check that `unit == this.unit`. Why is this? if (tree == this.tree && owner == this.owner && scope == this.scope) this else make(tree, owner, scope, unit) @@ -508,17 +533,20 @@ trait Contexts { self: Analyzer => def makeNewScope(tree: Tree, owner: Symbol): Context = make(tree, owner, newNestedScope(scope)) + /** Make a child context that buffers errors and warnings into a fresh report buffer. */ def makeSilent(reportAmbiguousErrors: Boolean = ambiguousErrors, newtree: Tree = tree): Context = { val c = make(newtree) c.setBufferErrors() c.setAmbiguousErrors(reportAmbiguousErrors) - c._reportBuffer = new ReportBuffer // A fresh buffer so as not to leak errors/warnings into `this`. + // A fresh buffer so as not to leak errors/warnings into `this`. + c._reportBuffer = new BufferingReporter c } def makeNonSilent(newtree: Tree): Context = { val c = make(newtree) + c._reportBuffer = (new ContextReporter).sharingBuffersWith(reportBuffer) c.setReportErrors() c.setAmbiguousErrors(true) c @@ -545,6 +573,7 @@ trait Contexts { self: Analyzer => val baseContext = enclClass.outer.nextEnclosing(!_.tree.isInstanceOf[Template]) val argContext = baseContext.makeNewScope(tree, owner) argContext.contextMode = contextMode + argContext._reportBuffer = _reportBuffer // caught by neg/t3649 TODO: make sure _reportBuffer is propagated wherever contextMode is argContext.inSelfSuperCall = true def enterElems(c: Context) { def enterLocalElems(e: ScopeEntry) { @@ -567,46 +596,17 @@ trait Contexts { self: Analyzer => // // Error and warning issuance // - private def addDiagString(msg: String) = { - val diagUsedDefaultsMsg = "Error occurred in an application involving default arguments." - if (diagUsedDefaults && !(msg endsWith diagUsedDefaultsMsg)) msg + "\n" + diagUsedDefaultsMsg - else msg - } - - private def unitError(pos: Position, msg: String): Unit = - if (checking) onTreeCheckerError(pos, msg) - else reporter.error(pos, msg) - - @inline private def issueCommon(err: AbsTypeError, reportError: Boolean) { - // TODO: are errors allowed to have pos == NoPosition?? - // if not, Jason suggests doing: val pos = err.errPos.orElse( { devWarning("Que?"); context.tree.pos }) - if (settings.Yissuedebug) { - log("issue error: " + err.errMsg) - (new Exception).printStackTrace() - } - if (reportError) unitError(err.errPos, addDiagString(err.errMsg)) - else if (bufferErrors) { reportBuffer += err } - else throw new TypeError(err.errPos, err.errMsg) - } /** Issue/buffer/throw the given type error according to the current mode for error reporting. */ - private[typechecker] def issue(err: AbsTypeError) = issueCommon(err, reportErrors) - + private[typechecker] def issue(err: AbsTypeError) = reportBuffer.issue(err)(this) /** Issue/buffer/throw the given implicit ambiguity error according to the current mode for error reporting. */ - private[typechecker] def issueAmbiguousError(err: AbsTypeError) = issueCommon(err, ambiguousErrors) - + private[typechecker] def issueAmbiguousError(err: AbsAmbiguousTypeError) = reportBuffer.issueAmbiguousError(err)(this) /** Issue/throw the given error message according to the current mode for error reporting. */ - def error(pos: Position, msg: String) = { - val msg1 = addDiagString(msg) - if (reportErrors) unitError(pos, msg1) - else throw new TypeError(pos, msg1) - } - + def error(pos: Position, msg: String) = reportBuffer.error(pos, msg) /** Issue/throw the given error message according to the current mode for error reporting. */ - def warning(pos: Position, msg: String) { - if (reportErrors) reporter.warning(pos, msg) - else if (bufferErrors) reportBuffer += (pos -> msg) - } + def warning(pos: Position, msg: String) = reportBuffer.warning(pos, msg) + def echo(pos: Position, msg: String) = reportBuffer.echo(pos, msg) + def deprecationWarning(pos: Position, sym: Symbol, msg: String): Unit = currentRun.reporting.deprecationWarning(pos, sym, msg) @@ -616,7 +616,6 @@ trait Contexts { self: Analyzer => def featureWarning(pos: Position, featureName: String, featureDesc: String, featureTrait: Symbol, construct: => String = "", required: Boolean): Unit = currentRun.reporting.featureWarning(pos, featureName, featureDesc, featureTrait, construct, required) - def echo(pos: Position, msg: String): Unit = reporter.echo(pos, msg) // nextOuter determines which context is searched next for implicits // (after `this`, which contributes `newImplicits` below.) In @@ -1254,7 +1253,7 @@ trait Contexts { self: Analyzer => } /** A buffer for warnings and errors that are accumulated during speculative type checking. */ - final class ReportBuffer { + class ContextReporter extends Reporter { type Error = AbsTypeError type Warning = (Position, String) @@ -1270,6 +1269,13 @@ trait Contexts { self: Analyzer => private def warningBuffer = {if (_warningBuffer == null) _warningBuffer = newBuffer; _warningBuffer} def warnings: immutable.Seq[Warning] = warningBuffer.toVector + def sharingBuffersWith(other: ContextReporter): this.type = { + // go through other's accessor so that its buffer will be created + _errorBuffer = other.errorBuffer + _warningBuffer = other.warningBuffer + this + } + def +=(error: AbsTypeError): this.type = { errorBuffer += error this @@ -1296,7 +1302,8 @@ trait Contexts { self: Analyzer => this } - def hasErrors = errorBuffer.nonEmpty + // TODO + override def hasErrors = super.hasErrors || errorBuffer.nonEmpty def firstError = errorBuffer.headOption // have to pass in context because multiple contexts may share the same ReportBuffer @@ -1323,8 +1330,52 @@ trait Contexts { self: Analyzer => case err: DivergentImplicitTypeError => err ne saved case _ => false } + + def isBuffering = false + + protected def addDiagString(msg: String)(implicit context: Context): String = { + val diagUsedDefaultsMsg = "Error occurred in an application involving default arguments." + if (context.diagUsedDefaults && !(msg endsWith diagUsedDefaultsMsg)) msg + "\n" + diagUsedDefaultsMsg + else msg + } + + def issue(err: AbsTypeError)(implicit context: Context): Unit = error(err.errPos, addDiagString(err.errMsg)) + + def issueAmbiguousError(err: AbsAmbiguousTypeError)(implicit context: Context): Unit = + if (context.ambiguousErrors) error(err.errPos, addDiagString(err.errMsg)) + + protected final def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit = ??? + override def echo(pos: Position, msg: String): Unit = reporter.echo(pos, msg) + override def warning(pos: Position, msg: String): Unit = reporter.warning(pos, msg) + override def error(pos: Position, msg: String): Unit = reporter.error(pos, msg) } + private class BufferingReporter extends ContextReporter { + override def isBuffering = true + + override def issue(err: AbsTypeError)(implicit context: Context): Unit = this += err + override def issueAmbiguousError(err: AbsAmbiguousTypeError)(implicit context: Context): Unit = + if (context.ambiguousErrors) reporter.error(err.errPos, addDiagString(err.errMsg)) + else this += err + + override def warning(pos: Position, msg: String): Unit = this += (pos -> msg) + + // this used to throw new TypeError(pos, msg) -- buffering lets us report more errors (test/files/neg/macro-basic-mamdmi) + // the old throwing behavior was relied on by diagnostics in manifestOfType + override def error(pos: Position, msg: String): Unit = this += TypeErrorWrapper(new TypeError(pos, msg)) + } + + // TODO: remove (specialization relies on TypeError being thrown, among other post-typer phases) + private class ThrowingReporter extends ContextReporter { + override def error(pos: Position, msg: String): Unit = throw new TypeError(pos, msg) + } + + /** Used during a run of [[scala.tools.nsc.typechecker.TreeCheckers]]? */ + private class CheckingReporter extends ContextReporter { + override def error(pos: Position, msg: String): Unit = onTreeCheckerError(pos, msg) + } + + class ImportInfo(val tree: Import, val depth: Int) { def pos = tree.pos def posOf(sel: ImportSelector) = tree.pos withPoint sel.namePos diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index ed773f01780e..0a5521aff419 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -1276,19 +1276,20 @@ trait Implicits { if (tagInScope.isEmpty) mot(tp, Nil, Nil) else { if (ReflectRuntimeUniverse == NoSymbol) { - // todo. write a test for this - context.error(pos, + // TODO: write a test for this (the next error message is already checked by neg/interop_typetags_without_classtags_arenot_manifests.scala) + // TODO: this was using context.error, and implicit search always runs in silent mode, thus it was actually throwing a TypeError + // with the new strategy-based reporting, a BufferingReporter buffers instead of throwing + // it would be good to rework this logic to fit into the regular context.error mechanism + throw new TypeError(pos, sm"""to create a manifest here, it is necessary to interoperate with the type tag `$tagInScope` in scope. |however typetag -> manifest conversion requires Scala reflection, which is not present on the classpath. |to proceed put scala-reflect.jar on your compilation classpath and recompile.""") - return SearchFailure } if (resolveClassTag(pos, tp, allowMaterialization = true) == EmptyTree) { - context.error(pos, + throw new TypeError(pos, sm"""to create a manifest here, it is necessary to interoperate with the type tag `$tagInScope` in scope. |however typetag -> manifest conversion requires a class tag for the corresponding type to be present. |to proceed add a class tag to the type `$tp` (e.g. by introducing a context bound) and recompile.""") - return SearchFailure } val cm = typed(Ident(ReflectRuntimeCurrentMirror)) val internal = gen.mkAttributedSelect(gen.mkAttributedRef(ReflectRuntimeUniverse), UniverseInternal) diff --git a/test/files/neg/macro-basic-mamdmi.check b/test/files/neg/macro-basic-mamdmi.check index 61df5131ccb2..54743d4936da 100644 --- a/test/files/neg/macro-basic-mamdmi.check +++ b/test/files/neg/macro-basic-mamdmi.check @@ -1,5 +1,13 @@ +Impls_Macros_Test_1.scala:33: error: macro implementation not found: foo +(the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them) + println(foo(2) + Macros.bar(2) * new Macros().quux(4)) + ^ +Impls_Macros_Test_1.scala:33: error: macro implementation not found: bar +(the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them) + println(foo(2) + Macros.bar(2) * new Macros().quux(4)) + ^ Impls_Macros_Test_1.scala:33: error: macro implementation not found: quux (the most common reason for that is that you cannot use macro implementations in the same compilation run that defines them) println(foo(2) + Macros.bar(2) * new Macros().quux(4)) ^ -one error found +three errors found From 258d95c7b1528a84514a6a609a356be840322e9b Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 17 Jul 2014 12:40:26 +0200 Subject: [PATCH 429/826] Remove dead code: mode setting --- .../tools/nsc/typechecker/Contexts.scala | 49 +++++-------------- 1 file changed, 12 insertions(+), 37 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 37eff40dd8db..06375d404b16 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -258,8 +258,6 @@ trait Contexts { self: Analyzer => def macrosEnabled = this(MacrosEnabled) def enrichmentEnabled_=(value: Boolean) = this(EnrichmentEnabled) = value def enrichmentEnabled = this(EnrichmentEnabled) - def checking_=(value: Boolean) = this(Checking) = value - def checking = this(Checking) def retyping_=(value: Boolean) = this(ReTyping) = value def retyping = this(ReTyping) def inSecondTry = this(SecondTry) @@ -329,28 +327,16 @@ trait Contexts { self: Analyzer => // TODO: start out with a regular reporter? private var _reportBuffer: ContextReporter = new ThrowingReporter - /** A buffer for errors and warnings, used with `this.bufferErrors == true` */ - def reportBuffer = { - assert( - (bufferErrors == _reportBuffer.isInstanceOf[BufferingReporter]) - && (throwErrors == _reportBuffer.isInstanceOf[ThrowingReporter]) - && (checking == _reportBuffer.isInstanceOf[CheckingReporter]) - && (reportErrors != (_reportBuffer.isInstanceOf[BufferingReporter] - || _reportBuffer.isInstanceOf[ThrowingReporter] - || _reportBuffer.isInstanceOf[CheckingReporter])), - s"INCONSISTENCY $contextMode != ${_reportBuffer.getClass}") - - _reportBuffer - } + // the reporter for this context + def reportBuffer = _reportBuffer + + // if set, errors will not be reporter/thrown + def bufferErrors = reportBuffer.isBuffering + def reportErrors = !bufferErrors - def reportErrors = contextMode.inNone(ThrowErrors | BufferErrors) - def bufferErrors = this(BufferErrors) + // whether to *report* (which is separate from buffering/throwing) ambiguity errors def ambiguousErrors = this(AmbiguousErrors) - private def throwErrors = this(ThrowErrors) - private def setReportErrors(): Unit = set(disable = BufferErrors | ThrowErrors) - private def setBufferErrors(): Unit = set(enable = BufferErrors, disable = ThrowErrors) - private def setThrowErrors(): Unit = set(enable = ThrowErrors, disable = BufferErrors) private def setAmbiguousErrors(report: Boolean): Unit = this(AmbiguousErrors) = report @@ -366,7 +352,6 @@ trait Contexts { self: Analyzer => val savedReporter = _reportBuffer var fallback = false _reportBuffer = (new BufferingReporter).sharingBuffersWith(reportBuffer) - setBufferErrors() setAmbiguousErrors(false) // We cache the current buffer because it is impossible to // distinguish errors that occurred before entering tryTwice @@ -441,9 +426,8 @@ trait Contexts { self: Analyzer => /** @return true if the `expr` evaluates to true within a silent Context that incurs no errors */ @inline final def inSilentMode(expr: => Boolean): Boolean = { val savedReporter = _reportBuffer - withMode() { // withMode with no arguments to restore the mode mutated by `setBufferErrors`. + withMode() { // TODO: rework -- withMode with no arguments to restore the mode mutated by `setBufferErrors` (no longer mutated!) _reportBuffer = (new BufferingReporter).sharingBuffersWith(reportBuffer) - setBufferErrors() setAmbiguousErrors(false) try expr && !reportBuffer.hasErrors finally { @@ -515,9 +499,9 @@ trait Contexts { self: Analyzer => /** Use reporter (possibly buffered) for errors/warnings and enable implicit conversion **/ def initRootContext(throwing: Boolean = false, checking: Boolean = false): Unit = { _reportBuffer = - if (checking) {this.checking = true ; new CheckingReporter} - else if (throwing) {setThrowErrors(); new ThrowingReporter} - else {setReportErrors() ; new ContextReporter} // TODO: this is likely redundant + if (checking) new CheckingReporter + else if (throwing) new ThrowingReporter + else new ContextReporter // TODO: this is likely redundant setAmbiguousErrors(!throwing) this(EnrichmentEnabled | ImplicitsEnabled) = !throwing @@ -537,7 +521,6 @@ trait Contexts { self: Analyzer => /** Make a child context that buffers errors and warnings into a fresh report buffer. */ def makeSilent(reportAmbiguousErrors: Boolean = ambiguousErrors, newtree: Tree = tree): Context = { val c = make(newtree) - c.setBufferErrors() c.setAmbiguousErrors(reportAmbiguousErrors) // A fresh buffer so as not to leak errors/warnings into `this`. c._reportBuffer = new BufferingReporter @@ -547,7 +530,6 @@ trait Contexts { self: Analyzer => def makeNonSilent(newtree: Tree): Context = { val c = make(newtree) c._reportBuffer = (new ContextReporter).sharingBuffersWith(reportBuffer) - c.setReportErrors() c.setAmbiguousErrors(true) c } @@ -1468,8 +1450,6 @@ object ContextMode { def apply(bits: Int): ContextMode = new ContextMode(bits) final val NOmode: ContextMode = 0 - final val ThrowErrors: ContextMode = 1 << 0 - final val BufferErrors: ContextMode = 1 << 1 final val AmbiguousErrors: ContextMode = 1 << 2 /** Are we in a secondary constructor after the this constructor call? */ @@ -1492,8 +1472,6 @@ object ContextMode { /** To selectively allow enrichment in patterns, where other kinds of implicit conversions are not allowed */ final val EnrichmentEnabled: ContextMode = 1 << 8 - /** Are we in a run of [[scala.tools.nsc.typechecker.TreeCheckers]]? */ - final val Checking: ContextMode = 1 << 9 /** Are we retypechecking arguments independently from the function applied to them? See `Typer.tryTypedApply` * TODO - iron out distinction/overlap with SecondTry. @@ -1530,17 +1508,14 @@ object ContextMode { PatternAlternative | StarPatterns | SuperInit | SecondTry | ReturnExpr | TypeConstructorAllowed ) - final val DefaultMode: ContextMode = MacrosEnabled | ThrowErrors + final val DefaultMode: ContextMode = MacrosEnabled private val contextModeNameMap = Map( - ThrowErrors -> "ReportErrors", - BufferErrors -> "BufferErrors", AmbiguousErrors -> "AmbiguousErrors", ConstructorSuffix -> "ConstructorSuffix", SelfSuperCall -> "SelfSuperCall", ImplicitsEnabled -> "ImplicitsEnabled", MacrosEnabled -> "MacrosEnabled", - Checking -> "Checking", ReTyping -> "ReTyping", PatternAlternative -> "PatternAlternative", StarPatterns -> "StarPatterns", From 9707e1df533dd678531c653f5ddedda59df5ce9c Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Thu, 17 Jul 2014 12:47:40 +0200 Subject: [PATCH 430/826] s/reportBuffer/reporter --- .../tools/nsc/typechecker/Contexts.scala | 59 +++++++++---------- .../tools/nsc/typechecker/Implicits.scala | 32 +++++----- .../scala/tools/nsc/typechecker/Infer.scala | 2 +- .../scala/tools/nsc/typechecker/Macros.scala | 2 +- .../scala/tools/nsc/typechecker/Typers.scala | 36 +++++------ 5 files changed, 65 insertions(+), 66 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 06375d404b16..1d4e2c854622 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -128,7 +128,7 @@ trait Contexts { self: Analyzer => case Import(qual, _) => qual setType singleType(qual.symbol.owner.thisType, qual.symbol) case _ => } - context.reportBuffer.clearAll() + context.reporter.clearAll() } } @@ -324,14 +324,13 @@ trait Contexts { self: Analyzer => // Error reporting policies and buffer. // - // TODO: start out with a regular reporter? - private var _reportBuffer: ContextReporter = new ThrowingReporter + private var _reporter: ContextReporter = new ThrowingReporter // the reporter for this context - def reportBuffer = _reportBuffer + def reporter = _reporter // if set, errors will not be reporter/thrown - def bufferErrors = reportBuffer.isBuffering + def bufferErrors = reporter.isBuffering def reportErrors = !bufferErrors // whether to *report* (which is separate from buffering/throwing) ambiguity errors @@ -349,9 +348,9 @@ trait Contexts { self: Analyzer => def apply(): Unit = if (implicitsEnabled) { val savedContextMode = contextMode - val savedReporter = _reportBuffer + val savedReporter = _reporter var fallback = false - _reportBuffer = (new BufferingReporter).sharingBuffersWith(reportBuffer) + _reporter = (new BufferingReporter).sharingBuffersWith(reporter) setAmbiguousErrors(false) // We cache the current buffer because it is impossible to // distinguish errors that occurred before entering tryTwice @@ -359,27 +358,27 @@ trait Contexts { self: Analyzer => // first attempt fails we try with implicits on *and* clean // buffer but that would also flush any pre-tryTwice valid // errors, hence some manual buffer tweaking is necessary. - val errorsToRestore = reportBuffer.errors - reportBuffer.clearAllErrors() + val errorsToRestore = reporter.errors + reporter.clearAllErrors() try { withImplicitsDisabled(tryOnce(false)) - if (reportBuffer.hasErrors) { + if (reporter.hasErrors) { fallback = true contextMode = savedContextMode - _reportBuffer = savedReporter - reportBuffer.clearAllErrors() + _reporter = savedReporter + reporter.clearAllErrors() tryOnce(true) } } catch { case ex: CyclicReference => throw ex case ex: TypeError => // recoverable cyclic references contextMode = savedContextMode - _reportBuffer = savedReporter + _reporter = savedReporter if (!fallback) tryOnce(true) else () } finally { contextMode = savedContextMode - _reportBuffer = savedReporter - reportBuffer ++= errorsToRestore + _reporter = savedReporter + reporter ++= errorsToRestore } } else tryOnce(true) @@ -425,14 +424,14 @@ trait Contexts { self: Analyzer => /** @return true if the `expr` evaluates to true within a silent Context that incurs no errors */ @inline final def inSilentMode(expr: => Boolean): Boolean = { - val savedReporter = _reportBuffer + val savedReporter = _reporter withMode() { // TODO: rework -- withMode with no arguments to restore the mode mutated by `setBufferErrors` (no longer mutated!) - _reportBuffer = (new BufferingReporter).sharingBuffersWith(reportBuffer) + _reporter = (new BufferingReporter).sharingBuffersWith(reporter) setAmbiguousErrors(false) - try expr && !reportBuffer.hasErrors + try expr && !reporter.hasErrors finally { - _reportBuffer = savedReporter - _reportBuffer.clearAll() // TODO: ??? + _reporter = savedReporter + _reporter.clearAll() // TODO: ??? } } } @@ -481,7 +480,7 @@ trait Contexts { self: Analyzer => c.diagUsedDefaults = diagUsedDefaults c.openImplicits = openImplicits c.contextMode = contextMode // note: ConstructorSuffix, a bit within `mode`, is conditionally overwritten below. - c._reportBuffer = _reportBuffer + c._reporter = reporter // Fields that may take on a different value in the child c.prefix = prefixInChild @@ -498,7 +497,7 @@ trait Contexts { self: Analyzer => /** Use reporter (possibly buffered) for errors/warnings and enable implicit conversion **/ def initRootContext(throwing: Boolean = false, checking: Boolean = false): Unit = { - _reportBuffer = + _reporter = if (checking) new CheckingReporter else if (throwing) new ThrowingReporter else new ContextReporter // TODO: this is likely redundant @@ -523,13 +522,13 @@ trait Contexts { self: Analyzer => val c = make(newtree) c.setAmbiguousErrors(reportAmbiguousErrors) // A fresh buffer so as not to leak errors/warnings into `this`. - c._reportBuffer = new BufferingReporter + c._reporter = new BufferingReporter c } def makeNonSilent(newtree: Tree): Context = { val c = make(newtree) - c._reportBuffer = (new ContextReporter).sharingBuffersWith(reportBuffer) + c._reporter = (new ContextReporter).sharingBuffersWith(reporter) c.setAmbiguousErrors(true) c } @@ -555,7 +554,7 @@ trait Contexts { self: Analyzer => val baseContext = enclClass.outer.nextEnclosing(!_.tree.isInstanceOf[Template]) val argContext = baseContext.makeNewScope(tree, owner) argContext.contextMode = contextMode - argContext._reportBuffer = _reportBuffer // caught by neg/t3649 TODO: make sure _reportBuffer is propagated wherever contextMode is + argContext._reporter = _reporter // caught by neg/t3649 TODO: make sure _reporter is propagated wherever contextMode is argContext.inSelfSuperCall = true def enterElems(c: Context) { def enterLocalElems(e: ScopeEntry) { @@ -580,14 +579,14 @@ trait Contexts { self: Analyzer => // /** Issue/buffer/throw the given type error according to the current mode for error reporting. */ - private[typechecker] def issue(err: AbsTypeError) = reportBuffer.issue(err)(this) + private[typechecker] def issue(err: AbsTypeError) = reporter.issue(err)(this) /** Issue/buffer/throw the given implicit ambiguity error according to the current mode for error reporting. */ - private[typechecker] def issueAmbiguousError(err: AbsAmbiguousTypeError) = reportBuffer.issueAmbiguousError(err)(this) + private[typechecker] def issueAmbiguousError(err: AbsAmbiguousTypeError) = reporter.issueAmbiguousError(err)(this) /** Issue/throw the given error message according to the current mode for error reporting. */ - def error(pos: Position, msg: String) = reportBuffer.error(pos, msg) + def error(pos: Position, msg: String) = reporter.error(pos, msg) /** Issue/throw the given error message according to the current mode for error reporting. */ - def warning(pos: Position, msg: String) = reportBuffer.warning(pos, msg) - def echo(pos: Position, msg: String) = reportBuffer.echo(pos, msg) + def warning(pos: Position, msg: String) = reporter.warning(pos, msg) + def echo(pos: Position, msg: String) = reporter.echo(pos, msg) def deprecationWarning(pos: Position, sym: Symbol, msg: String): Unit = diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index 0a5521aff419..e03877dbf99f 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -71,12 +71,12 @@ trait Implicits { typingStack.printTyping(tree, "typing implicit: %s %s".format(tree, context.undetparamsString)) val implicitSearchContext = context.makeImplicit(reportAmbiguous) val result = new ImplicitSearch(tree, pt, isView, implicitSearchContext, pos).bestImplicit - if (result.isFailure && saveAmbiguousDivergent && implicitSearchContext.reportBuffer.hasErrors) { - context.reportBuffer ++= (implicitSearchContext.reportBuffer.errors.collect { + if (result.isFailure && saveAmbiguousDivergent && implicitSearchContext.reporter.hasErrors) { + context.reporter ++= (implicitSearchContext.reporter.errors.collect { case dte: DivergentImplicitTypeError => dte case ate: AmbiguousImplicitTypeError => ate }) - debuglog("update buffer: " + implicitSearchContext.reportBuffer.errors) + debuglog("update buffer: " + implicitSearchContext.reporter.errors) } // SI-7944 undetermined type parameters that result from inference within typedImplicit land in // `implicitSearchContext.undetparams`, *not* in `context.undetparams` @@ -99,7 +99,7 @@ trait Implicits { def wrapper(inference: => SearchResult) = wrapper1(inference) val result = wrapper(inferImplicit(tree, pt, reportAmbiguous = true, isView = isView, context = context, saveAmbiguousDivergent = !silent, pos = pos)) if (result.isFailure && !silent) { - val err = context.reportBuffer.firstError + val err = context.reporter.firstError val errPos = err.map(_.errPos).getOrElse(pos) val errMsg = err.map(_.errMsg).getOrElse("implicit search has failed. to find out the reason, turn on -Xlog-implicits") onError(errPos, errMsg) @@ -635,7 +635,7 @@ trait Implicits { } case _ => fallback } - context.reportBuffer.firstError match { // using match rather than foreach to avoid non local return. + context.reporter.firstError match { // using match rather than foreach to avoid non local return. case Some(err) => log("implicit adapt failed: " + err.errMsg) return fail(err.errMsg) @@ -658,8 +658,8 @@ trait Implicits { } } - if (context.reportBuffer.hasErrors) - fail("hasMatchingSymbol reported error: " + context.reportBuffer.firstError.get.errMsg) + if (context.reporter.hasErrors) + fail("hasMatchingSymbol reported error: " + context.reporter.firstError.get.errMsg) else if (itree3.isErroneous) fail("error typechecking implicit candidate") else if (isLocalToCallsite && !hasMatchingSymbol(itree2)) @@ -677,7 +677,7 @@ trait Implicits { // #2421: check that we correctly instantiated type parameters outside of the implicit tree: checkBounds(itree3, NoPrefix, NoSymbol, undetParams, targs, "inferred ") - context.reportBuffer.firstError match { + context.reporter.firstError match { case Some(err) => return fail("type parameters weren't correctly instantiated outside of the implicit tree: " + err.errMsg) case None => @@ -716,7 +716,7 @@ trait Implicits { case t => t } - context.reportBuffer.firstError match { + context.reporter.firstError match { case Some(err) => fail("typing TypeApply reported errors for the implicit tree: " + err.errMsg) case None => @@ -861,7 +861,7 @@ trait Implicits { // We don't want errors that occur while checking the implicit info // to influence the check of further infos, but we should retain divergent implicit errors // (except for the one we already squirreled away) - context.reportBuffer.retainDivergentErrorsExcept(divergentError.getOrElse(null)) + context.reporter.retainDivergentErrorsExcept(divergentError.getOrElse(null)) } search } @@ -907,7 +907,7 @@ trait Implicits { // the first `DivergentImplicitTypeError` that is being propagated // from a nested implicit search; this one will be // re-issued if this level of the search fails. - DivergentImplicitRecovery(typedFirstPending, firstPending, context.reportBuffer.errors) match { + DivergentImplicitRecovery(typedFirstPending, firstPending, context.reporter.errors) match { case sr if sr.isDivergent => Nil case sr if sr.isFailure => rankImplicits(otherPending, acc) case newBest => @@ -1144,7 +1144,7 @@ trait Implicits { try { val tree1 = typedPos(pos.focus)(arg) - context.reportBuffer.firstError match { + context.reporter.firstError match { case Some(err) => processMacroExpansionError(err.errPos, err.errMsg) case None => new SearchResult(tree1, EmptyTreeTypeSubstituter, Nil) } @@ -1357,8 +1357,8 @@ trait Implicits { if (Statistics.canEnable) Statistics.incCounter(inscopeImplicitHits) } if (result.isFailure) { - val previousErrs = context.reportBuffer.errors - context.reportBuffer.clearAllErrors() + val previousErrs = context.reporter.errors + context.reporter.clearAllErrors() val failstart = if (Statistics.canEnable) Statistics.startTimer(oftypeFailNanos) else null val succstart = if (Statistics.canEnable) Statistics.startTimer(oftypeSucceedNanos) else null @@ -1370,7 +1370,7 @@ trait Implicits { result = searchImplicit(implicitsOfExpectedType, isLocalToCallsite = false) if (result.isFailure) { - context.reportBuffer ++= previousErrs + context.reporter ++= previousErrs if (Statistics.canEnable) Statistics.stopTimer(oftypeFailNanos, failstart) } else { if (Statistics.canEnable) Statistics.stopTimer(oftypeSucceedNanos, succstart) @@ -1427,7 +1427,7 @@ trait Implicits { // thus, start each type var off with a fresh for every typedImplicit resetTVars() // any previous errors should not affect us now - context.reportBuffer.clearAllErrors() + context.reporter.clearAllErrors() val res = typedImplicit(ii, ptChecked = false, isLocalToCallsite) if (res.tree ne EmptyTree) List((res, tvars map (_.constr))) else Nil diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index 69ac9ea61e60..535aaffbbf90 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -779,7 +779,7 @@ trait Infer extends Checkable { def applicableExpectingPt(pt: Type): Boolean = { val silent = context.makeSilent(reportAmbiguousErrors = false) val result = newTyper(silent).infer.isApplicable(undetparams, ftpe, argtpes0, pt) - if (silent.reportBuffer.hasErrors && !pt.isWildcard) + if (silent.reporter.hasErrors && !pt.isWildcard) applicableExpectingPt(WildcardType) // second try else result diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala index 66152a6ac237..d6870afb10f2 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala @@ -622,7 +622,7 @@ trait Macros extends MacroRuntimes with Traces with Helpers { // `macroExpandApply` is called from `adapt`, where implicit conversions are disabled // therefore we need to re-enable the conversions back temporarily val result = typer.context.withImplicitsEnabled(typer.typed(tree, mode, pt)) - if (result.isErrorTyped && macroDebugVerbose) println(s"$label has failed: ${typer.context.reportBuffer.errors}") + if (result.isErrorTyped && macroDebugVerbose) println(s"$label has failed: ${typer.context.reporter.errors}") result } } diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 65dc5148ad89..c557af88f23b 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -155,7 +155,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper } else { mkArg = gen.mkNamedArg // don't pass the default argument (if any) here, but start emitting named arguments for the following args if (!param.hasDefault && !paramFailed) { - context.reportBuffer.reportFirstDivergentError(fun, param, paramTp)(context) + context.reporter.reportFirstDivergentError(fun, param, paramTp)(context) paramFailed = true } /* else { @@ -466,20 +466,20 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper @inline final def typerWithLocalContext[T](c: Context)(f: Typer => T): T = { val res = f(newTyper(c)) - val errors = c.reportBuffer.errors + val errors = c.reporter.errors if (errors.nonEmpty) { - c.reportBuffer.clearAllErrors() - context.reportBuffer ++= errors + c.reporter.clearAllErrors() + context.reporter ++= errors } res } @inline final def withSavedContext[T](c: Context)(f: => T) = { - val savedErrors = c.reportBuffer.errors - c.reportBuffer.clearAllErrors() + val savedErrors = c.reporter.errors + c.reporter.clearAllErrors() val res = f - c.reportBuffer ++= savedErrors + c.reporter ++= savedErrors res } @@ -687,23 +687,23 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper context.undetparams = context1.undetparams context.savedTypeBounds = context1.savedTypeBounds context.namedApplyBlockInfo = context1.namedApplyBlockInfo - if (context1.reportBuffer.hasErrors) { + if (context1.reporter.hasErrors) { stopStats() - SilentTypeError(context1.reportBuffer.errors: _*) + SilentTypeError(context1.reporter.errors: _*) } else { // If we have a successful result, emit any warnings it created. - context1.reportBuffer.warnings foreach { + context1.reporter.warnings foreach { case (pos, msg) => reporter.warning(pos, msg) } - context1.reportBuffer.clearAllWarnings() + context1.reporter.clearAllWarnings() SilentResultValue(result) } } else { assert(context.bufferErrors || isPastTyper, "silent mode is not available past typer") withSavedContext(context){ val res = op(this) - val errorsToReport = context.reportBuffer.errors - context.reportBuffer.clearAllErrors() + val errorsToReport = context.reporter.errors + context.reporter.clearAllErrors() if (errorsToReport.isEmpty) SilentResultValue(res) else SilentTypeError(errorsToReport.head) } } @@ -810,14 +810,14 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper } // avoid throwing spurious DivergentImplicit errors - if (context.reportBuffer.hasErrors) + if (context.reporter.hasErrors) setError(tree) else withCondConstrTyper(treeInfo.isSelfOrSuperConstrCall(tree))(typer1 => if (original != EmptyTree && pt != WildcardType) ( typer1 silent { tpr => val withImplicitArgs = tpr.applyImplicitArgs(tree) - if (tpr.context.reportBuffer.hasErrors) tree // silent will wrap it in SilentTypeError anyway + if (tpr.context.reporter.hasErrors) tree // silent will wrap it in SilentTypeError anyway else tpr.typed(withImplicitArgs, mode, pt) } orElse { _ => @@ -1051,7 +1051,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper val silentContext = context.makeImplicit(context.ambiguousErrors) val res = newTyper(silentContext).typed( new ApplyImplicitView(coercion, List(tree)) setPos tree.pos, mode, pt) - silentContext.reportBuffer.firstError match { + silentContext.reporter.firstError match { case Some(err) => context.issue(err) case None => return res } @@ -3223,7 +3223,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper (arg1, arg1.tpe.deconst) }.unzip } - if (context.reportBuffer.hasErrors) + if (context.reporter.hasErrors) setError(tree) else { inferMethodAlternative(fun, undetparams, argTpes, pt) @@ -4324,7 +4324,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper c.retyping = true try { val res = newTyper(c).typedArgs(args, mode) - if (c.reportBuffer.hasErrors) None else Some(res) + if (c.reporter.hasErrors) None else Some(res) } catch { case ex: CyclicReference => throw ex From 5d00b5940a9c91b6d9e13fea625d406ce53cc60c Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 15 Jul 2014 18:43:45 +0200 Subject: [PATCH 431/826] Cleanup ContextReporter hierarchy Next step: more principled buffering, make use of the single-entry point reporter. First example simplification in `TryTwice`: No need to store and restore errors -- just use a fresh reporter. Also, control-flow with vars ftw. --- .../tools/nsc/typechecker/Contexts.scala | 178 +++++++++--------- 1 file changed, 84 insertions(+), 94 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 1d4e2c854622..fd9d1de88ee1 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -324,9 +324,10 @@ trait Contexts { self: Analyzer => // Error reporting policies and buffer. // + // the reporter for this context + // TODO: start off with ImmediateReporter private var _reporter: ContextReporter = new ThrowingReporter - // the reporter for this context def reporter = _reporter // if set, errors will not be reporter/thrown @@ -339,49 +340,45 @@ trait Contexts { self: Analyzer => private def setAmbiguousErrors(report: Boolean): Unit = this(AmbiguousErrors) = report - /** Try inference twice, once without views and once with views, + /** + * Try inference twice, once without views and once with views, * unless views are already disabled. */ abstract class TryTwice { def tryOnce(isLastTry: Boolean): Unit - def apply(): Unit = + def apply(): Unit = { + var doLastTry = !implicitsEnabled + + // do first try if implicits are enabled if (implicitsEnabled) { - val savedContextMode = contextMode val savedReporter = _reporter - var fallback = false - _reporter = (new BufferingReporter).sharingBuffersWith(reporter) - setAmbiguousErrors(false) - // We cache the current buffer because it is impossible to + val savedContextMode = contextMode + + _reporter = new BufferingReporter + setAmbiguousErrors(false) // this means ambiguous errors will not be force-fed to the reporter + + // We create a new BufferingReporter to // distinguish errors that occurred before entering tryTwice // and our first attempt in 'withImplicitsDisabled'. If the - // first attempt fails we try with implicits on *and* clean - // buffer but that would also flush any pre-tryTwice valid - // errors, hence some manual buffer tweaking is necessary. - val errorsToRestore = reporter.errors - reporter.clearAllErrors() + // first attempt fails, we try with implicits on + // and the original reporter. try { withImplicitsDisabled(tryOnce(false)) - if (reporter.hasErrors) { - fallback = true - contextMode = savedContextMode - _reporter = savedReporter - reporter.clearAllErrors() - tryOnce(true) - } + doLastTry = reporter.hasErrors } catch { - case ex: CyclicReference => throw ex - case ex: TypeError => // recoverable cyclic references - contextMode = savedContextMode - _reporter = savedReporter - if (!fallback) tryOnce(true) else () + case ex: CyclicReference => throw ex + case ex: TypeError => doLastTry = true // recoverable cyclic references? } finally { contextMode = savedContextMode _reporter = savedReporter - reporter ++= errorsToRestore } } - else tryOnce(true) + + // do last try if try with implicits enabled failed + // (or if it was not attempted because they were disabled) + if (doLastTry) tryOnce(true) + } } // @@ -426,7 +423,7 @@ trait Contexts { self: Analyzer => @inline final def inSilentMode(expr: => Boolean): Boolean = { val savedReporter = _reporter withMode() { // TODO: rework -- withMode with no arguments to restore the mode mutated by `setBufferErrors` (no longer mutated!) - _reporter = (new BufferingReporter).sharingBuffersWith(reporter) + _reporter = reporter.makeBuffering setAmbiguousErrors(false) try expr && !reporter.hasErrors finally { @@ -500,7 +497,7 @@ trait Contexts { self: Analyzer => _reporter = if (checking) new CheckingReporter else if (throwing) new ThrowingReporter - else new ContextReporter // TODO: this is likely redundant + else new ImmediateReporter setAmbiguousErrors(!throwing) this(EnrichmentEnabled | ImplicitsEnabled) = !throwing @@ -528,7 +525,7 @@ trait Contexts { self: Analyzer => def makeNonSilent(newtree: Tree): Context = { val c = make(newtree) - c._reporter = (new ContextReporter).sharingBuffersWith(reporter) + c._reporter = reporter.makeImmediate c.setAmbiguousErrors(true) c } @@ -1234,58 +1231,39 @@ trait Contexts { self: Analyzer => } /** A buffer for warnings and errors that are accumulated during speculative type checking. */ - class ContextReporter extends Reporter { + abstract class ContextReporter(private[this] var _errorBuffer: mutable.LinkedHashSet[AbsTypeError] = null, private[this] var _warningBuffer: mutable.LinkedHashSet[(Position, String)] = null) extends Reporter { type Error = AbsTypeError type Warning = (Position, String) - private def newBuffer[A] = mutable.LinkedHashSet.empty[A] // Important to use LinkedHS for stable results. + def issue(err: AbsTypeError)(implicit context: Context): Unit = handleError(err.errPos, addDiagString(err.errMsg)) - // [JZ] Contexts, pre- the SI-7345 refactor, avoided allocating the buffers until needed. This - // is replicated here out of conservatism. - private var _errorBuffer: mutable.LinkedHashSet[Error] = _ - private def errorBuffer = {if (_errorBuffer == null) _errorBuffer = newBuffer; _errorBuffer} - def errors: immutable.Seq[Error] = errorBuffer.toVector - - private var _warningBuffer: mutable.LinkedHashSet[Warning] = _ - private def warningBuffer = {if (_warningBuffer == null) _warningBuffer = newBuffer; _warningBuffer} - def warnings: immutable.Seq[Warning] = warningBuffer.toVector - - def sharingBuffersWith(other: ContextReporter): this.type = { - // go through other's accessor so that its buffer will be created - _errorBuffer = other.errorBuffer - _warningBuffer = other.warningBuffer - this - } + protected def handleError(pos: Position, msg: String): Unit + protected def handleSuppressedAmbiguous(err: AbsAmbiguousTypeError): Unit = () + protected def handleWarning(pos: Position, msg: String): Unit = reporter.warning(pos, msg) - def +=(error: AbsTypeError): this.type = { - errorBuffer += error - this - } - def ++=(errors: Traversable[AbsTypeError]): this.type = { - errorBuffer ++= errors - this - } - def +=(warning: Warning): this.type = { - warningBuffer += warning - this - } + def makeImmediate: ContextReporter = this + def makeBuffering: ContextReporter = this + def isBuffering: Boolean = false - def clearAll(): this.type = { - clearAllErrors(); clearAllWarnings(); - } + /** Emit an ambiguous error according to context.ambiguousErrors + * + * - when true, use global.reporter regardless of whether we're buffering (TODO: can we change this?) + * - else, let this context reporter decide + */ + final def issueAmbiguousError(err: AbsAmbiguousTypeError)(implicit context: Context): Unit = + if (context.ambiguousErrors) reporter.error(err.errPos, addDiagString(err.errMsg)) // force reporting... see TODO above + else handleSuppressedAmbiguous(err) - def clearAllErrors(): this.type = { - errorBuffer.clear() - this - } - def clearAllWarnings(): this.type = { - warningBuffer.clear() - this - } + def ++=(errors: Traversable[AbsTypeError]): Unit = errorBuffer ++= errors + + protected final def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit = + severity match { + case ERROR => handleError(pos, msg) + case WARNING => handleWarning(pos, msg) + case INFO => reporter.echo(pos, msg) + } - // TODO - override def hasErrors = super.hasErrors || errorBuffer.nonEmpty - def firstError = errorBuffer.headOption + final override def hasErrors = super.hasErrors || errorBuffer.nonEmpty // have to pass in context because multiple contexts may share the same ReportBuffer def reportFirstDivergentError(fun: Tree, param: Symbol, paramTp: Type)(implicit context: Context): Unit = @@ -1312,48 +1290,60 @@ trait Contexts { self: Analyzer => case _ => false } - def isBuffering = false - protected def addDiagString(msg: String)(implicit context: Context): String = { val diagUsedDefaultsMsg = "Error occurred in an application involving default arguments." if (context.diagUsedDefaults && !(msg endsWith diagUsedDefaultsMsg)) msg + "\n" + diagUsedDefaultsMsg else msg } - def issue(err: AbsTypeError)(implicit context: Context): Unit = error(err.errPos, addDiagString(err.errMsg)) + // TODO: deprecate everything below (related to buffering) and push down to BufferingReporter + // [JZ] Contexts, pre- the SI-7345 refactor, avoided allocating the buffers until needed. This + // is replicated here out of conservatism. + private def newBuffer[A] = mutable.LinkedHashSet.empty[A] // Important to use LinkedHS for stable results. + final protected def errorBuffer = { if (_errorBuffer == null) _errorBuffer = newBuffer; _errorBuffer } + final protected def warningBuffer = { if (_warningBuffer == null) _warningBuffer = newBuffer; _warningBuffer } - def issueAmbiguousError(err: AbsAmbiguousTypeError)(implicit context: Context): Unit = - if (context.ambiguousErrors) error(err.errPos, addDiagString(err.errMsg)) + final def errors: immutable.Seq[Error] = errorBuffer.toVector + final def warnings: immutable.Seq[Warning] = warningBuffer.toVector + final def firstError: Option[AbsTypeError] = errorBuffer.headOption - protected final def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit = ??? - override def echo(pos: Position, msg: String): Unit = reporter.echo(pos, msg) - override def warning(pos: Position, msg: String): Unit = reporter.warning(pos, msg) - override def error(pos: Position, msg: String): Unit = reporter.error(pos, msg) + final def clearAll(): Unit = { clearAllErrors(); clearAllWarnings() } + final def clearAllErrors(): Unit = errorBuffer.clear() + final def clearAllWarnings(): Unit = warningBuffer.clear() } - private class BufferingReporter extends ContextReporter { - override def isBuffering = true + private class ImmediateReporter(_errorBuffer: mutable.LinkedHashSet[AbsTypeError] = null, _warningBuffer: mutable.LinkedHashSet[(Position, String)] = null) extends ContextReporter(_errorBuffer, _warningBuffer) { + override def makeBuffering: ContextReporter = new BufferingReporter(errorBuffer, warningBuffer) + protected def handleError(pos: Position, msg: String): Unit = reporter.error(pos, msg) + } - override def issue(err: AbsTypeError)(implicit context: Context): Unit = this += err - override def issueAmbiguousError(err: AbsAmbiguousTypeError)(implicit context: Context): Unit = - if (context.ambiguousErrors) reporter.error(err.errPos, addDiagString(err.errMsg)) - else this += err - override def warning(pos: Position, msg: String): Unit = this += (pos -> msg) + private class BufferingReporter(_errorBuffer: mutable.LinkedHashSet[AbsTypeError] = null, _warningBuffer: mutable.LinkedHashSet[(Position, String)] = null) extends ContextReporter(_errorBuffer, _warningBuffer) { + override def isBuffering = true + + override def issue(err: AbsTypeError)(implicit context: Context): Unit = errorBuffer += err // this used to throw new TypeError(pos, msg) -- buffering lets us report more errors (test/files/neg/macro-basic-mamdmi) // the old throwing behavior was relied on by diagnostics in manifestOfType - override def error(pos: Position, msg: String): Unit = this += TypeErrorWrapper(new TypeError(pos, msg)) + protected def handleError(pos: Position, msg: String): Unit = errorBuffer += TypeErrorWrapper(new TypeError(pos, msg)) + override protected def handleSuppressedAmbiguous(err: AbsAmbiguousTypeError): Unit = errorBuffer += err + override protected def handleWarning(pos: Position, msg: String): Unit = warningBuffer += ((pos, msg)) + + // TODO: emit all buffered errors, warnings + override def makeImmediate: ContextReporter = new ImmediateReporter(errorBuffer, warningBuffer) } - // TODO: remove (specialization relies on TypeError being thrown, among other post-typer phases) + /** Used after typer (specialization relies on TypeError being thrown, among other post-typer phases). + * + * TODO: get rid of it, use ImmediateReporter and a check for reporter.hasErrors where necessary + */ private class ThrowingReporter extends ContextReporter { - override def error(pos: Position, msg: String): Unit = throw new TypeError(pos, msg) + protected def handleError(pos: Position, msg: String): Unit = throw new TypeError(pos, msg) } /** Used during a run of [[scala.tools.nsc.typechecker.TreeCheckers]]? */ private class CheckingReporter extends ContextReporter { - override def error(pos: Position, msg: String): Unit = onTreeCheckerError(pos, msg) + protected def handleError(pos: Position, msg: String): Unit = onTreeCheckerError(pos, msg) } From abb58dcef1b4758f4e3af26c030e1f0630b8d145 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Sun, 27 Apr 2014 00:08:54 -0700 Subject: [PATCH 432/826] SI-6476 Improve error on escapement Behavior of escape processing under string interpolation can be confusing. This commit improves the exception message so you know at least what sort of escapes are handled. This came up on SO in the form `s"\d".r`, where it may not be obvious what is throwing and how to work around it. ``` scala> s"\d".r scala.StringContext$InvalidEscapeException: invalid escape '\d' not one of [\b, \t, \n, \f, \r, \\, \", \'] at index 0 in "\d". Use \\ for literal \. scala> s"a\" scala.StringContext$InvalidEscapeException: invalid escape at terminal index 1 in "a\". Use \\ for literal \. ``` Referencing SI-6476 because that has become the magnet ticket for "escape processing under string interpolation, huh?" This doesn't address `$"` and doesn't handle the more interesting parse error `s"a\"b"`. --- src/library/scala/StringContext.scala | 9 +++++++-- test/files/neg/t8266-invalid-interp.check | 4 ++-- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/src/library/scala/StringContext.scala b/src/library/scala/StringContext.scala index c0468e8b021d..0b0818210218 100644 --- a/src/library/scala/StringContext.scala +++ b/src/library/scala/StringContext.scala @@ -175,8 +175,13 @@ object StringContext { * @param str The offending string * @param idx The index of the offending backslash character in `str`. */ - class InvalidEscapeException(str: String, @deprecatedName('idx) val index: Int) - extends IllegalArgumentException("invalid escape character at index "+index+" in \""+str+"\"") + class InvalidEscapeException(str: String, @deprecatedName('idx) val index: Int) extends IllegalArgumentException( + s"""invalid escape ${ + require(index >= 0 && index < str.length) + val ok = """[\b, \t, \n, \f, \r, \\, \", \']""" + if (index == str.length - 1) "at terminal" else s"'\\${str(index + 1)}' not one of $ok at" + } index $index in "$str". Use \\\\ for literal \\.""" + ) /** Expands standard Scala escape sequences in a string. * Escape sequences are: diff --git a/test/files/neg/t8266-invalid-interp.check b/test/files/neg/t8266-invalid-interp.check index 70dd4081b017..bb2d44a80cab 100644 --- a/test/files/neg/t8266-invalid-interp.check +++ b/test/files/neg/t8266-invalid-interp.check @@ -1,10 +1,10 @@ t8266-invalid-interp.scala:4: error: Trailing '\' escapes nothing. f"a\", ^ -t8266-invalid-interp.scala:5: error: invalid escape character at index 1 in "a\xc" +t8266-invalid-interp.scala:5: error: invalid escape '\x' not one of [\b, \t, \n, \f, \r, \\, \", \'] at index 1 in "a\xc". Use \\ for literal \. f"a\xc", ^ -t8266-invalid-interp.scala:7: error: invalid escape character at index 1 in "a\vc" +t8266-invalid-interp.scala:7: error: invalid escape '\v' not one of [\b, \t, \n, \f, \r, \\, \", \'] at index 1 in "a\vc". Use \\ for literal \. f"a\vc" ^ three errors found From b4f506749189b337bd25633d521b6b917108ee15 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Fri, 18 Jul 2014 22:34:01 -0700 Subject: [PATCH 433/826] SI-6476 Documentation And adjust the test. --- .../scala/tools/nsc/ast/parser/Parsers.scala | 2 ++ test/files/run/t6631.scala | 18 ------------------ test/junit/scala/StringContextTest.scala | 14 ++++++++++++++ 3 files changed, 16 insertions(+), 18 deletions(-) delete mode 100644 test/files/run/t6631.scala diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index 883fd31dbc99..90bc53721d72 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -1254,6 +1254,8 @@ self => } if (in.token == STRINGLIT) partsBuf += literal() + // Documenting that it is intentional that the ident is not rooted for purposes of virtualization + //val t1 = atPos(o2p(start)) { Select(Select (Ident(nme.ROOTPKG), nme.scala_), nme.StringContext) } val t1 = atPos(o2p(start)) { Ident(nme.StringContext) } val t2 = atPos(start) { Apply(t1, partsBuf.toList) } t2 setPos t2.pos.makeTransparent diff --git a/test/files/run/t6631.scala b/test/files/run/t6631.scala deleted file mode 100644 index e472b83d50a6..000000000000 --- a/test/files/run/t6631.scala +++ /dev/null @@ -1,18 +0,0 @@ -import reflect.ClassTag - -object Test extends App { - def intercept[T <: Throwable : ClassTag](act: => Any) = try { - act - } catch { - case x: Throwable => - val cls = implicitly[ClassTag[T]].runtimeClass - assert(cls.isInstance(x), (x.getClass, x, cls).toString) - } - assert(s"""\f\r\n\t""" == "\f\r\n\t") - - import StringContext.InvalidEscapeException - intercept[InvalidEscapeException](s"""\""") - intercept[InvalidEscapeException](s"""\x""") - intercept[InvalidEscapeException](s"\") - -} diff --git a/test/junit/scala/StringContextTest.scala b/test/junit/scala/StringContextTest.scala index 5abfe90cd159..bb0e8c425263 100644 --- a/test/junit/scala/StringContextTest.scala +++ b/test/junit/scala/StringContextTest.scala @@ -48,4 +48,18 @@ class StringContextTest { val res = processEscapes(s) assertEquals("Scala", res) } + + @Test def t6631_baseline() = assertEquals("\f\r\n\t", s"""\f\r\n\t""") + + @Test def t6631_badEscape() = assertThrows[InvalidEscapeException] { + s"""\x""" + } + + // verifying that the standard interpolators can be supplanted + @Test def antiHijack_?() = { + object AllYourStringsAreBelongToMe { case class StringContext(args: Any*) { def s(args: Any) = "!!!!" } } + import AllYourStringsAreBelongToMe._ + //assertEquals("????", s"????") + assertEquals("!!!!", s"????") // OK to hijack core interpolator ids + } } From ccbb84bb87a9dd828fa3aca1a1a14487e327ec5b Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Sat, 19 Jul 2014 19:26:39 -0700 Subject: [PATCH 434/826] SI-6476 Unitize procedures, readability Strictly trivial updates for readability. I used to prefer procedure syntax, but since it was scheduled for removal, I can't scan a def without an equals sign. --- .../scala/tools/nsc/ast/parser/Parsers.scala | 36 +++++++++---------- .../scala/tools/nsc/ast/parser/Scanners.scala | 16 ++++----- 2 files changed, 24 insertions(+), 28 deletions(-) diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index 90bc53721d72..9350a39cbef0 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -204,13 +204,11 @@ self => override def newScanner() = new UnitScanner(unit, patches) - override def warning(offset: Offset, msg: String) { + override def warning(offset: Offset, msg: String): Unit = reporter.warning(o2p(offset), msg) - } - override def deprecationWarning(offset: Offset, msg: String) { + override def deprecationWarning(offset: Offset, msg: String): Unit = currentRun.reporting.deprecationWarning(o2p(offset), msg) - } private var smartParsing = false @inline private def withSmartParsing[T](body: => T): T = { @@ -226,12 +224,12 @@ self => for ((offset, msg) <- syntaxErrors) reporter.error(o2p(offset), msg) - override def syntaxError(offset: Offset, msg: String) { + override def syntaxError(offset: Offset, msg: String): Unit = { if (smartParsing) syntaxErrors += ((offset, msg)) else reporter.error(o2p(offset), msg) } - override def incompleteInputError(msg: String) { + override def incompleteInputError(msg: String): Unit = { val offset = source.content.length - 1 if (smartParsing) syntaxErrors += ((offset, msg)) else currentRun.reporting.incompleteInputError(o2p(offset), msg) @@ -544,27 +542,25 @@ self => } def warning(offset: Offset, msg: String): Unit def incompleteInputError(msg: String): Unit - private def syntaxError(pos: Position, msg: String, skipIt: Boolean) { - syntaxError(pos pointOrElse in.offset, msg, skipIt) - } def syntaxError(offset: Offset, msg: String): Unit - def syntaxError(msg: String, skipIt: Boolean) { + + private def syntaxError(pos: Position, msg: String, skipIt: Boolean): Unit = + syntaxError(pos pointOrElse in.offset, msg, skipIt) + def syntaxError(msg: String, skipIt: Boolean): Unit = syntaxError(in.offset, msg, skipIt) - } - def syntaxError(offset: Offset, msg: String, skipIt: Boolean) { + def syntaxError(offset: Offset, msg: String, skipIt: Boolean): Unit = { if (offset > lastErrorOffset) { syntaxError(offset, msg) - // no more errors on this token. - lastErrorOffset = in.offset + lastErrorOffset = in.offset // no more errors on this token. } if (skipIt) skip(UNDEF) } - def warning(msg: String) { warning(in.offset, msg) } + def warning(msg: String): Unit = warning(in.offset, msg) - def syntaxErrorOrIncomplete(msg: String, skipIt: Boolean) { + def syntaxErrorOrIncomplete(msg: String, skipIt: Boolean): Unit = { if (in.token == EOF) incompleteInputError(msg) else @@ -1233,15 +1229,15 @@ self => skipIt = true)(EmptyTree) // Like Swiss cheese, with holes def stringCheese: Tree = atPos(in.offset) { - val start = in.offset + val start = in.offset val interpolator = in.name.encoded // ident() for INTERPOLATIONID val partsBuf = new ListBuffer[Tree] - val exprBuf = new ListBuffer[Tree] + val exprsBuf = new ListBuffer[Tree] in.nextToken() while (in.token == STRINGPART) { partsBuf += literal() - exprBuf += ( + exprsBuf += ( if (inPattern) dropAnyBraces(pattern()) else in.token match { case IDENTIFIER => atPos(in.offset)(Ident(ident())) @@ -1260,7 +1256,7 @@ self => val t2 = atPos(start) { Apply(t1, partsBuf.toList) } t2 setPos t2.pos.makeTransparent val t3 = Select(t2, interpolator) setPos t2.pos - atPos(start) { Apply(t3, exprBuf.toList) } + atPos(start) { Apply(t3, exprsBuf.toList) } } if (inPattern) stringCheese else withPlaceholders(stringCheese, isAny = true) // strinterpolator params are Any* by definition diff --git a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala index 572497ac9010..5ae9fd3f563c 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala @@ -688,9 +688,11 @@ trait Scanners extends ScannersCommon { setStrVal() nextChar() token = STRINGLIT - } else syntaxError("unclosed string literal") + } else unclosedStringLit() } + private def unclosedStringLit(): Unit = syntaxError("unclosed string literal") + private def getRawStringLit(): Unit = { if (ch == '\"') { nextRawChar() @@ -764,7 +766,7 @@ trait Scanners extends ScannersCommon { if (multiLine) incompleteInputError("unclosed multi-line string literal") else - syntaxError("unclosed string literal") + unclosedStringLit() } else { putChar(ch) @@ -1068,21 +1070,19 @@ trait Scanners extends ScannersCommon { // Errors ----------------------------------------------------------------- - /** generate an error at the given offset - */ - def syntaxError(off: Offset, msg: String) { + /** generate an error at the given offset */ + def syntaxError(off: Offset, msg: String): Unit = { error(off, msg) token = ERROR } - /** generate an error at the current token offset - */ + /** generate an error at the current token offset */ def syntaxError(msg: String): Unit = syntaxError(offset, msg) def deprecationWarning(msg: String): Unit = deprecationWarning(offset, msg) /** signal an error where the input ended in the middle of a token */ - def incompleteInputError(msg: String) { + def incompleteInputError(msg: String): Unit = { incompleteInputError(offset, msg) token = EOF } From eff9a584a68c65935c313a6f26d7d4f778a61703 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Sat, 19 Jul 2014 19:57:02 -0700 Subject: [PATCH 435/826] SI-6476 Unitize ALL the procedures! --- .../scala/tools/nsc/ast/parser/Parsers.scala | 18 +++++----- .../scala/tools/nsc/ast/parser/Scanners.scala | 35 +++++++++---------- 2 files changed, 26 insertions(+), 27 deletions(-) diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index 9350a39cbef0..c90f0d017330 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -154,8 +154,8 @@ self => def unit = global.currentUnit // suppress warnings; silent abort on errors - def warning(offset: Offset, msg: String) {} - def deprecationWarning(offset: Offset, msg: String) {} + def warning(offset: Offset, msg: String): Unit = () + def deprecationWarning(offset: Offset, msg: String): Unit = () def syntaxError(offset: Offset, msg: String): Unit = throw new MalformedInput(offset, msg) def incompleteInputError(msg: String): Unit = throw new MalformedInput(source.content.length - 1, msg) @@ -333,7 +333,7 @@ self => */ private var inScalaPackage = false private var currentPackage = "" - def resetPackage() { + def resetPackage(): Unit = { inScalaPackage = false currentPackage = "" } @@ -512,7 +512,7 @@ self => finally inFunReturnType = saved } - protected def skip(targetToken: Token) { + protected def skip(targetToken: Token): Unit = { var nparens = 0 var nbraces = 0 while (true) { @@ -715,7 +715,7 @@ self => /** Convert tree to formal parameter. */ def convertToParam(tree: Tree): ValDef = atPos(tree.pos) { - def removeAsPlaceholder(name: Name) { + def removeAsPlaceholder(name: Name): Unit = { placeholderParams = placeholderParams filter (_.name != name) } def errorParam = makeParam(nme.ERROR, errorTypeTree setPos o2p(tree.pos.end)) @@ -1264,21 +1264,21 @@ self => /* ------------- NEW LINES ------------------------------------------------- */ - def newLineOpt() { + def newLineOpt(): Unit = { if (in.token == NEWLINE) in.nextToken() } - def newLinesOpt() { + def newLinesOpt(): Unit = { if (in.token == NEWLINE || in.token == NEWLINES) in.nextToken() } - def newLineOptWhenFollowedBy(token: Offset) { + def newLineOptWhenFollowedBy(token: Offset): Unit = { // note: next is defined here because current == NEWLINE if (in.token == NEWLINE && in.next.token == token) newLineOpt() } - def newLineOptWhenFollowing(p: Token => Boolean) { + def newLineOptWhenFollowing(p: Token => Boolean): Unit = { // note: next is defined here because current == NEWLINE if (in.token == NEWLINE && p(in.next.token)) newLineOpt() } diff --git a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala index 5ae9fd3f563c..0248806fff9e 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Scanners.scala @@ -113,7 +113,7 @@ trait Scanners extends ScannersCommon { case SU | CR | LF => case _ => nextChar() ; skipLineComment() } - private def maybeOpen() { + private def maybeOpen(): Unit = { putCommentChar() if (ch == '*') { putCommentChar() @@ -137,7 +137,7 @@ trait Scanners extends ScannersCommon { def skipDocComment(): Unit = skipNestedComments() def skipBlockComment(): Unit = skipNestedComments() - private def skipToCommentEnd(isLineComment: Boolean) { + private def skipToCommentEnd(isLineComment: Boolean): Unit = { nextChar() if (isLineComment) skipLineComment() else { @@ -185,7 +185,7 @@ trait Scanners extends ScannersCommon { /** append Unicode character to "cbuf" buffer */ - protected def putChar(c: Char) { + protected def putChar(c: Char): Unit = { // assert(cbuf.size < 10000, cbuf) cbuf.append(c) } @@ -196,7 +196,7 @@ trait Scanners extends ScannersCommon { protected def emitIdentifierDeprecationWarnings = true /** Clear buffer and set name and token */ - private def finishNamed(idtoken: Token = IDENTIFIER) { + private def finishNamed(idtoken: Token = IDENTIFIER): Unit = { name = newTermName(cbuf.toString) cbuf.clear() token = idtoken @@ -215,7 +215,7 @@ trait Scanners extends ScannersCommon { } /** Clear buffer and set string */ - private def setStrVal() { + private def setStrVal(): Unit = { strVal = cbuf.toString cbuf.clear() } @@ -270,7 +270,7 @@ trait Scanners extends ScannersCommon { /** Produce next token, filling TokenData fields of Scanner. */ - def nextToken() { + def nextToken(): Unit = { val lastToken = token // Adapt sepRegions according to last token (lastToken: @switch) match { @@ -341,7 +341,7 @@ trait Scanners extends ScannersCommon { prev copyFrom this val nextLastOffset = charOffset - 1 fetchToken() - def resetOffset() { + def resetOffset(): Unit = { offset = prev.offset lastOffset = prev.lastOffset } @@ -399,7 +399,7 @@ trait Scanners extends ScannersCommon { /** read next token, filling TokenData fields of Scanner. */ - protected final def fetchToken() { + protected final def fetchToken(): Unit = { offset = charOffset - 1 (ch: @switch) match { @@ -604,7 +604,7 @@ trait Scanners extends ScannersCommon { // Identifiers --------------------------------------------------------------- - private def getBackquotedIdent() { + private def getBackquotedIdent(): Unit = { nextChar() getLitChars('`') if (ch == '`') { @@ -664,7 +664,7 @@ trait Scanners extends ScannersCommon { else finishNamed() } - private def getIdentOrOperatorRest() { + private def getIdentOrOperatorRest(): Unit = { if (isIdentifierPart(ch)) getIdentRest() else ch match { @@ -859,7 +859,7 @@ trait Scanners extends ScannersCommon { /** read fractional part and exponent of floating point number * if one is present. */ - protected def getFraction() { + protected def getFraction(): Unit = { token = DOUBLELIT while ('0' <= ch && ch <= '9') { putChar(ch) @@ -968,14 +968,13 @@ trait Scanners extends ScannersCommon { def floatVal: Double = floatVal(negated = false) - def checkNoLetter() { + def checkNoLetter(): Unit = { if (isIdentifierPart(ch) && ch >= ' ') syntaxError("Invalid literal number") } - /** Read a number into strVal and set base - */ - protected def getNumber() { + /** Read a number into strVal and set base */ + protected def getNumber(): Unit = { val base1 = if (base < 10) 10 else base // Read 8,9's even if format is octal, produce a malformed number error afterwards. // At this point, we have already read the first digit, so to tell an innocent 0 apart @@ -1054,7 +1053,7 @@ trait Scanners extends ScannersCommon { /** Parse character literal if current character is followed by \', * or follow with given op and return a symbol literal token */ - def charLitOr(op: () => Unit) { + def charLitOr(op: () => Unit): Unit = { putChar(ch) nextChar() if (ch == '\'') { @@ -1134,7 +1133,7 @@ trait Scanners extends ScannersCommon { /** Initialization method: read first char, then first token */ - def init() { + def init(): Unit = { nextChar() nextToken() } @@ -1490,6 +1489,6 @@ trait Scanners extends ScannersCommon { // when skimming through the source file trying to heal braces override def emitIdentifierDeprecationWarnings = false - override def error(offset: Offset, msg: String) {} + override def error(offset: Offset, msg: String): Unit = () } } From c7cc1a803764b4d26dd23d2baf34a27a3a40f682 Mon Sep 17 00:00:00 2001 From: Rex Kerr Date: Sun, 20 Jul 2014 12:36:25 -0700 Subject: [PATCH 436/826] SI-8738 Regression in range equality Missed the case of comparing a non-empty range to an empty one. Fixed by checking nonEmpty/isEmpty on other collection. Added a test to verify the behavior. --- .../scala/collection/immutable/Range.scala | 19 ++++++++++--------- test/files/run/t8738.scala | 16 ++++++++++++++++ 2 files changed, 26 insertions(+), 9 deletions(-) create mode 100644 test/files/run/t8738.scala diff --git a/src/library/scala/collection/immutable/Range.scala b/src/library/scala/collection/immutable/Range.scala index 26ccd0980345..720dfeed59a0 100644 --- a/src/library/scala/collection/immutable/Range.scala +++ b/src/library/scala/collection/immutable/Range.scala @@ -364,15 +364,16 @@ extends scala.collection.AbstractSeq[Int] override def equals(other: Any) = other match { case x: Range => // Note: this must succeed for overfull ranges (length > Int.MaxValue) - (x canEqual this) && ( - isEmpty || // all empty sequences are equal - (start == x.start && { // Otherwise, must have same start - val l0 = last - (l0 == x.last && ( // And same end - start == l0 || step == x.step // And either the same step, or not take any steps - )) - }) - ) + (x canEqual this) && { + if (isEmpty) x.isEmpty // empty sequences are equal + else // this is non-empty... + x.nonEmpty && start == x.start && { // ...so other must contain something and have same start + val l0 = last + (l0 == x.last && ( // And same end + start == l0 || step == x.step // And either the same step, or not take any steps + )) + } + } case _ => super.equals(other) } diff --git a/test/files/run/t8738.scala b/test/files/run/t8738.scala new file mode 100644 index 000000000000..6898301db7cf --- /dev/null +++ b/test/files/run/t8738.scala @@ -0,0 +1,16 @@ +object Test { + def check(a: Range, b: Range) = (a == b) == (a.toList == b.toList) + def main(args: Array[String]) { + val lo = -2 to 2 + val hi = lo + val step = List(-6,-2,-1,1,2,6) + for (i <- lo; j <- hi; n <- step; k <- lo; l <- hi; m <- step) { + assert( + check(i until j by n, k until l by m) && + check(i until j by n, k to l by m) && + check(i to j by n, k until l by m) && + check(i to j by n, k to l by m) + ) + } + } +} From 01da58e6b6d356e7830183806056e27f70099caf Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Sun, 20 Jul 2014 14:48:33 -0700 Subject: [PATCH 437/826] SI-8736 Restore -language to former glory MultiChoice allows -language to work like -Xlint. The bug as described was that the setting value was set instead of updated (++=) with additional flags. The unreported bug was that `_` no longer set all settings. The corrected behavior is that "contains" means "it was enabled, or _ was set and it was not disabled explicitly." That is the behavior of `-Xlint` but with a different mechanism, since each lint option is a Setting. A semantic difference is that -Xlint enables all the lint options, but -language does not enable all the language features. `scalac -X` does not explain this additional behavior of the `-Xlint` flag. Also worth noting that `scalac -feature -language unused.scala` failed in 2.11.1 but succeeds silently now. --- .../tools/nsc/settings/AbsScalaSettings.scala | 2 +- .../tools/nsc/settings/MutableSettings.scala | 19 +++++++++++++------ .../scala/tools/nsc/settings/Warnings.scala | 2 +- test/files/neg/t8736-c.check | 11 +++++++++++ test/files/neg/t8736-c.flags | 1 + test/files/neg/t8736-c.scala | 7 +++++++ test/files/pos/t8736-b.flags | 1 + test/files/pos/t8736-b.scala | 7 +++++++ test/files/pos/t8736.flags | 1 + test/files/pos/t8736.scala | 7 +++++++ 10 files changed, 50 insertions(+), 8 deletions(-) create mode 100644 test/files/neg/t8736-c.check create mode 100644 test/files/neg/t8736-c.flags create mode 100644 test/files/neg/t8736-c.scala create mode 100644 test/files/pos/t8736-b.flags create mode 100644 test/files/pos/t8736-b.scala create mode 100644 test/files/pos/t8736.flags create mode 100644 test/files/pos/t8736.scala diff --git a/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala index c73e7ce00e7a..d0b8fd70ed7c 100644 --- a/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala @@ -29,7 +29,7 @@ trait AbsScalaSettings { def ChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: String): ChoiceSetting def IntSetting(name: String, descr: String, default: Int, range: Option[(Int, Int)], parser: String => Option[Int]): IntSetting def MultiStringSetting(name: String, helpArg: String, descr: String): MultiStringSetting - def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: () => Unit)(helper: MultiChoiceSetting => String): MultiChoiceSetting + def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: Option[() => Unit])(helper: MultiChoiceSetting => String): MultiChoiceSetting def OutputSetting(outputDirs: OutputDirs, default: String): OutputSetting def PathSetting(name: String, descr: String, default: String): PathSetting def PhasesSetting(name: String, descr: String, default: String): PhasesSetting diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala index 3f41ede3ad1c..ed8fb2a630bc 100644 --- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala @@ -211,7 +211,7 @@ class MutableSettings(val errorFn: String => Unit) add(new ChoiceSetting(name, helpArg, descr, choices, default)) def IntSetting(name: String, descr: String, default: Int, range: Option[(Int, Int)], parser: String => Option[Int]) = add(new IntSetting(name, descr, default, range, parser)) def MultiStringSetting(name: String, arg: String, descr: String) = add(new MultiStringSetting(name, arg, descr)) - def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: () => Unit = () => ())( + def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: Option[() => Unit] = None)( helper: MultiChoiceSetting => String = _ => choices.mkString(f"$descr:%n", f"%n ", f"%n") ) = add(new MultiChoiceSetting(name, helpArg, descr, choices, default, helper)) @@ -563,19 +563,21 @@ class MutableSettings(val errorFn: String => Unit) arg: String, descr: String, override val choices: List[String], - val default: () => Unit, + val default: Option[() => Unit], helper: MultiChoiceSetting => String ) extends MultiStringSetting(name, s"_,$arg,-$arg", s"$descr: `_' for all, `$name:help' to list") { private def badChoice(s: String, n: String) = errorFn(s"'$s' is not a valid choice for '$name'") private def choosing = choices.nonEmpty private def isChoice(s: String) = (s == "_") || (choices contains (s stripPrefix "-")) + private var sawHelp = false + private var sawAll = false override protected def tts(args: List[String], halting: Boolean) = { val added = collection.mutable.ListBuffer.empty[String] def tryArg(arg: String) = arg match { - case "_" if choosing => default() + case "_" if choosing => addAll() case "help" if choosing => sawHelp = true case s if !choosing || isChoice(s) => added += s case s => badChoice(s, name) @@ -587,13 +589,18 @@ class MutableSettings(val errorFn: String => Unit) case Nil => Nil } val rest = loop(args) - if (rest.size == args.size) default() // if no arg consumed, trigger default action - else value = added.toList // update all new settings at once + if (rest.size == args.size) default foreach (_()) // if no arg consumed, trigger default action + else value ++= added.toList // update all new settings at once Some(rest) } def isHelping: Boolean = sawHelp - def help: String = helper(this) + def help: String = helper(this) + private val adderAll = Some(() => sawAll = true) + def addAll(): Unit = default orElse adderAll foreach (_()) + + // the semantics is: s is enabled, i.e., either s or (_ but not -s) + override def contains(s: String) = isChoice(s) && (value contains s) || (sawAll && !(value contains s"-$s")) } /** A setting that accumulates all strings supplied to it, diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala index 9989d1d1880e..bec068b56a17 100644 --- a/src/compiler/scala/tools/nsc/settings/Warnings.scala +++ b/src/compiler/scala/tools/nsc/settings/Warnings.scala @@ -116,7 +116,7 @@ trait Warnings { helpArg = "warning", descr = description, choices = choices, - default = () => xlint.value = true + default = Some(() => xlint.value = true) ) { s => def helpline(n: String) = lintWarnings.find(_.name == n).map(w => f" ${w.name}%-25s ${w.helpDescription}%n") choices flatMap (helpline(_)) mkString (f"$description:%n", "", f"%n") diff --git a/test/files/neg/t8736-c.check b/test/files/neg/t8736-c.check new file mode 100644 index 000000000000..06b222854380 --- /dev/null +++ b/test/files/neg/t8736-c.check @@ -0,0 +1,11 @@ +t8736-c.scala:4: warning: higher-kinded type should be enabled +by making the implicit value scala.language.higherKinds visible. +This can be achieved by adding the import clause 'import scala.language.higherKinds' +or by setting the compiler option -language:higherKinds. +See the Scala docs for value scala.language.higherKinds for a discussion +why the feature should be explicitly enabled. + def hk[M[_]] = ??? + ^ +error: No warnings can be incurred under -Xfatal-warnings. +one warning found +one error found diff --git a/test/files/neg/t8736-c.flags b/test/files/neg/t8736-c.flags new file mode 100644 index 000000000000..fde5313c96dd --- /dev/null +++ b/test/files/neg/t8736-c.flags @@ -0,0 +1 @@ +-feature -language:-higherKinds,_ -Xfatal-warnings diff --git a/test/files/neg/t8736-c.scala b/test/files/neg/t8736-c.scala new file mode 100644 index 000000000000..8432775ae1a4 --- /dev/null +++ b/test/files/neg/t8736-c.scala @@ -0,0 +1,7 @@ +// scalac: -feature -language:-higherKinds,_ -Xfatal-warnings +// showing that wildcard doesn't supersede explicit disablement +class X { + def hk[M[_]] = ??? + + implicit def imp(x: X): Int = x.hashCode +} diff --git a/test/files/pos/t8736-b.flags b/test/files/pos/t8736-b.flags new file mode 100644 index 000000000000..1ad4eabe0f4c --- /dev/null +++ b/test/files/pos/t8736-b.flags @@ -0,0 +1 @@ +-feature -language:_ -Xfatal-warnings diff --git a/test/files/pos/t8736-b.scala b/test/files/pos/t8736-b.scala new file mode 100644 index 000000000000..903292d23298 --- /dev/null +++ b/test/files/pos/t8736-b.scala @@ -0,0 +1,7 @@ +// scalac: -feature -language:_ -Xfatal-warnings +// showing that all are set +class X { + def hk[M[_]] = ??? + + implicit def imp(x: X): Int = x.hashCode +} diff --git a/test/files/pos/t8736.flags b/test/files/pos/t8736.flags new file mode 100644 index 000000000000..7fe42f7340ea --- /dev/null +++ b/test/files/pos/t8736.flags @@ -0,0 +1 @@ +-feature -language:implicitConversions -language:higherKinds -language:-implicitConversions -Xfatal-warnings diff --git a/test/files/pos/t8736.scala b/test/files/pos/t8736.scala new file mode 100644 index 000000000000..46c0cdfd000e --- /dev/null +++ b/test/files/pos/t8736.scala @@ -0,0 +1,7 @@ +// scalac: -feature -language:implicitConversions -language:higherKinds -language:-implicitConversions -Xfatal-warnings +// showing that multiple settings are respected, and explicit enablement has precedence +class X { + def hk[M[_]] = ??? + + implicit def imp(x: X): Int = x.hashCode +} From 5a30c40d3c9882bf4213124f8921b2be10d5f444 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Sun, 20 Jul 2014 21:11:55 -0700 Subject: [PATCH 438/826] SI-8736 Error if no arg and no default Now `-language` with no option will emit an error: ``` $ skalac -feature -language unused.scala scalac error: '-language' requires an option. See '-language:help'. scalac -help gives more information ``` --- .../tools/nsc/settings/MutableSettings.scala | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala index ed8fb2a630bc..f26192f88a51 100644 --- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala @@ -571,8 +571,10 @@ class MutableSettings(val errorFn: String => Unit) private def choosing = choices.nonEmpty private def isChoice(s: String) = (s == "_") || (choices contains (s stripPrefix "-")) - private var sawHelp = false - private var sawAll = false + private var sawHelp = false + private var sawAll = false + private val adderAll = () => sawAll = true + private val noargs = () => errorFn(s"'$name' requires an option. See '$name:help'.") override protected def tts(args: List[String], halting: Boolean) = { val added = collection.mutable.ListBuffer.empty[String] @@ -589,15 +591,16 @@ class MutableSettings(val errorFn: String => Unit) case Nil => Nil } val rest = loop(args) - if (rest.size == args.size) default foreach (_()) // if no arg consumed, trigger default action - else value ++= added.toList // update all new settings at once + if (rest.size == args.size) + (default getOrElse noargs)() // if no arg consumed, trigger default action or error + else + value ++= added.toList // update all new settings at once Some(rest) } def isHelping: Boolean = sawHelp def help: String = helper(this) - private val adderAll = Some(() => sawAll = true) - def addAll(): Unit = default orElse adderAll foreach (_()) + def addAll(): Unit = (default getOrElse adderAll)() // the semantics is: s is enabled, i.e., either s or (_ but not -s) override def contains(s: String) = isChoice(s) && (value contains s) || (sawAll && !(value contains s"-$s")) From 7a1863e7d2a7db5ab0ceecde436ab6d63e03a9f1 Mon Sep 17 00:00:00 2001 From: Dan Garrette Date: Mon, 21 Jul 2014 09:01:43 -0500 Subject: [PATCH 439/826] Remove "throws InvalidEscapeException" from StringContext.raw doc Since StringContext.raw doesn't escape its input, it does not call `treatEscapes` and cannot throw the InvalidEscapeException. --- src/library/scala/StringContext.scala | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/library/scala/StringContext.scala b/src/library/scala/StringContext.scala index c0468e8b021d..a99b9503ac52 100644 --- a/src/library/scala/StringContext.scala +++ b/src/library/scala/StringContext.scala @@ -112,8 +112,6 @@ case class StringContext(parts: String*) { * @throws An `IllegalArgumentException` * if the number of `parts` in the enclosing `StringContext` does not exceed * the number of arguments `arg` by exactly 1. - * @throws A `StringContext.InvalidEscapeException` if a `parts` string contains a backslash (`\`) character - * that does not start a valid escape sequence. */ def raw(args: Any*): String = standardInterpolator(identity, args) From 0f5580efb1d30b95513121bc499ba5187330f601 Mon Sep 17 00:00:00 2001 From: Dan Garrette Date: Mon, 21 Jul 2014 12:36:04 -0500 Subject: [PATCH 440/826] Fixed incorrect example in StringContext.raw doc As pointed out by @som-snytt, \u0023 is #, not \u0025. --- src/library/scala/StringContext.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/library/scala/StringContext.scala b/src/library/scala/StringContext.scala index a99b9503ac52..fe69c6fbf84a 100644 --- a/src/library/scala/StringContext.scala +++ b/src/library/scala/StringContext.scala @@ -104,7 +104,7 @@ case class StringContext(parts: String*) { * ''Note:'' Even when using the raw interpolator, Scala will preprocess unicode escapes. * For example: * {{{ - * scala> raw"\u005cu0025" + * scala> raw"\u005cu0023" * res0: String = # * }}} * From 0a1694d8048f01b7f0812cedaa341813e9044e7f Mon Sep 17 00:00:00 2001 From: Lukas Elmer Date: Mon, 21 Jul 2014 23:00:05 +0200 Subject: [PATCH 441/826] Fix scaladoc typo --- src/library/scala/math/Ordering.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/library/scala/math/Ordering.scala b/src/library/scala/math/Ordering.scala index d1a4e7c35c91..0d7ea8bce233 100644 --- a/src/library/scala/math/Ordering.scala +++ b/src/library/scala/math/Ordering.scala @@ -26,7 +26,7 @@ import scala.language.{implicitConversions, higherKinds} * val pairs = Array(("a", 5, 2), ("c", 3, 1), ("b", 1, 3)) * * // sort by 2nd element - * Sorting.quickSort(pairs)(Ordering.by[(String, Int, Int), Int](_._2) + * Sorting.quickSort(pairs)(Ordering.by[(String, Int, Int), Int](_._2)) * * // sort by the 3rd element, then 1st * Sorting.quickSort(pairs)(Ordering[(Int, String)].on(x => (x._3, x._1))) From 528df5becee03175e7462b64d7c22460cc5992f7 Mon Sep 17 00:00:00 2001 From: Malte Isberner Date: Mon, 21 Jul 2014 22:10:09 -0700 Subject: [PATCH 442/826] Fixed mathematically wrong statement in the documentation of scala.math.PartialOrdering. - Previous (misleading) documentation suggested that a partial ordering *is* an equivalence relation. This has now been clarified. - Existing documentation on properties of partial orderings (reflexive, transitive, antisymmetric) had several formatting inconsistencies that have now been remove. --- src/library/scala/math/PartialOrdering.scala | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/src/library/scala/math/PartialOrdering.scala b/src/library/scala/math/PartialOrdering.scala index 9e3538152848..8d7fc3253550 100644 --- a/src/library/scala/math/PartialOrdering.scala +++ b/src/library/scala/math/PartialOrdering.scala @@ -15,17 +15,24 @@ package math * latter. * * A [[http://en.wikipedia.org/wiki/Partial_order partial ordering]] is a - * binary relation on a type `T` that is also an equivalence relation on - * values of type `T`. This relation is exposed as the `lteq` method of - * the `PartialOrdering` trait. This relation must be: + * binary relation on a type `T`, exposed as the `lteq` method of this trait. + * This relation must be: * * - reflexive: `lteq(x, x) == '''true'''`, for any `x` of type `T`. - * - anti-symmetric: `lteq(x, y) == '''true'''` and `lteq(y, x) == true` - * then `equiv(x, y)`, for any `x` and `y` of type `T`. + * - anti-symmetric: if `lteq(x, y) == '''true'''` and + * `lteq(y, x) == '''true'''` + * then `equiv(x, y) == '''true'''`, for any `x` and `y` of type `T`. * - transitive: if `lteq(x, y) == '''true'''` and * `lteq(y, z) == '''true'''` then `lteq(x, z) == '''true'''`, * for any `x`, `y`, and `z` of type `T`. * + * Additionally, a partial ordering induces an + * [[http://en.wikipedia.org/wiki/Equivalence_relation equivalence relation]] + * on a type `T`: `x` and `y` of type `T` are equivalent if and only if + * `lteq(x, y) && lteq(y, x) == '''true'''`. This equivalence relation is + * exposed as the `equiv` method, inherited from the + * [[scala.math.Equiv Equiv]] trait. + * * @author Geoffrey Washburn * @version 1.0, 2008-04-0-3 * @since 2.7 From ee665e2f041b5e65f019e0168925b89d59d600d2 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 22 Jul 2014 15:15:46 +0200 Subject: [PATCH 443/826] Also update jline.version when update.versions is set during build --- build.xml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/build.xml b/build.xml index a89e694ac233..b7950f971ce5 100755 --- a/build.xml +++ b/build.xml @@ -558,6 +558,7 @@ TODO: + @@ -572,6 +573,7 @@ TODO: + From c4360481251fdec0599598c24da400a8bace3247 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Tue, 22 Jul 2014 14:45:12 +0200 Subject: [PATCH 444/826] Better error message than 'bad symbolic reference'. Let's not scare people, and try to give them some advice. PS: we should really come up with a better mechanism for testing errors/warnings --- .../scala/reflect/internal/pickling/UnPickler.scala | 11 ++++++----- test/files/neg/t5148.check | 9 +++++---- test/files/run/t6440.check | 9 +++++---- test/files/run/t6440b.check | 9 +++++---- ...ypetags_without_scala_reflect_typetag_lookup.scala | 4 ++-- ...thout_scala_reflect_typetag_manifest_interop.scala | 4 ++-- 6 files changed, 25 insertions(+), 21 deletions(-) diff --git a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala index b808666360a8..8d4c3f752f40 100644 --- a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala +++ b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala @@ -254,12 +254,13 @@ abstract class UnPickler { // (4) Call the mirror's "missing" hook. adjust(mirrorThatLoaded(owner).missingHook(owner, name)) orElse { // (5) Create a stub symbol to defer hard failure a little longer. - val fullName = s"${owner.fullName}.$name" + val advice = moduleAdvice(s"${owner.fullName}.$name") val missingMessage = - s"""|bad symbolic reference to $fullName encountered in class file '$filename'. - |Cannot access ${name.longString} in ${owner.kindString} ${owner.fullName}. The current classpath may be - |missing a definition for $fullName, or $filename may have been compiled against a version that's - |incompatible with the one found on the current classpath.${moduleAdvice(fullName)}""".stripMargin + s"""|missing or invalid dependency detected while loading class file '$filename'. + |Could not access ${name.longString} in ${owner.kindString} ${owner.fullName}, + |because it (or its dependencies) are missing. Check your build definition for + |missing or conflicting dependencies. (Re-run with `-Ylog-classpath` to see the problematic classpath.) + |A full rebuild may help if '$filename' was compiled against an incompatible version of ${owner.fullName}.$advice""".stripMargin owner.newStubSymbol(name, missingMessage) } } diff --git a/test/files/neg/t5148.check b/test/files/neg/t5148.check index 8a667f4b882b..0de4fe2d4c9c 100644 --- a/test/files/neg/t5148.check +++ b/test/files/neg/t5148.check @@ -1,5 +1,6 @@ -error: bad symbolic reference to scala.tools.nsc.interpreter.IMain.Request encountered in class file 'Imports.class'. -Cannot access type Request in class scala.tools.nsc.interpreter.IMain. The current classpath may be -missing a definition for scala.tools.nsc.interpreter.IMain.Request, or Imports.class may have been compiled against a version that's -incompatible with the one found on the current classpath. +error: missing or invalid dependency detected while loading class file 'Imports.class'. +Could not access type Request in class scala.tools.nsc.interpreter.IMain, +because it (or its dependencies) are missing. Check your build definition for +missing or conflicting dependencies. (Re-run with `-Ylog-classpath` to see the problematic classpath.) +A full rebuild may help if 'Imports.class' was compiled against an incompatible version of scala.tools.nsc.interpreter.IMain. one error found diff --git a/test/files/run/t6440.check b/test/files/run/t6440.check index 27d5d1380ecf..2358f08fcc71 100644 --- a/test/files/run/t6440.check +++ b/test/files/run/t6440.check @@ -1,4 +1,5 @@ -pos: source-newSource1.scala,line-9,offset=109 bad symbolic reference to .pack1 encountered in class file 'U.class'. -Cannot access term pack1 in package . The current classpath may be -missing a definition for .pack1, or U.class may have been compiled against a version that's -incompatible with the one found on the current classpath. ERROR +pos: source-newSource1.scala,line-9,offset=109 missing or invalid dependency detected while loading class file 'U.class'. +Could not access term pack1 in package , +because it (or its dependencies) are missing. Check your build definition for +missing or conflicting dependencies. (Re-run with `-Ylog-classpath` to see the problematic classpath.) +A full rebuild may help if 'U.class' was compiled against an incompatible version of . ERROR diff --git a/test/files/run/t6440b.check b/test/files/run/t6440b.check index 0b642c2c35f9..a6100d6d1ecf 100644 --- a/test/files/run/t6440b.check +++ b/test/files/run/t6440b.check @@ -1,4 +1,5 @@ -pos: NoPosition bad symbolic reference to pack1.T encountered in class file 'U.class'. -Cannot access type T in package pack1. The current classpath may be -missing a definition for pack1.T, or U.class may have been compiled against a version that's -incompatible with the one found on the current classpath. ERROR +pos: NoPosition missing or invalid dependency detected while loading class file 'U.class'. +Could not access type T in package pack1, +because it (or its dependencies) are missing. Check your build definition for +missing or conflicting dependencies. (Re-run with `-Ylog-classpath` to see the problematic classpath.) +A full rebuild may help if 'U.class' was compiled against an incompatible version of pack1. ERROR diff --git a/test/files/run/typetags_without_scala_reflect_typetag_lookup.scala b/test/files/run/typetags_without_scala_reflect_typetag_lookup.scala index 1fbdc62a1e18..3d2b9f77be3c 100644 --- a/test/files/run/typetags_without_scala_reflect_typetag_lookup.scala +++ b/test/files/run/typetags_without_scala_reflect_typetag_lookup.scala @@ -36,8 +36,8 @@ object Test extends StoreReporterDirectTest { println(filteredInfos.mkString("\n")) storeReporter.infos.clear() compileApp(); - // we should get bad symbolic reference errors, because we're trying to use an implicit that can't be unpickled + // we should get "missing or invalid dependency detected" errors, because we're trying to use an implicit that can't be unpickled // but we don't know the number of these errors and their order, so I just ignore them all - println(filteredInfos.filterNot(_.msg.contains("bad symbolic reference")).mkString("\n")) + println(filteredInfos.filterNot(_.msg.contains("missing or invalid dependency detected")).mkString("\n")) } } diff --git a/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.scala b/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.scala index 6804baa0c3cc..a865f4d137dd 100644 --- a/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.scala +++ b/test/files/run/typetags_without_scala_reflect_typetag_manifest_interop.scala @@ -40,8 +40,8 @@ object Test extends StoreReporterDirectTest { println(filteredInfos.mkString("\n")) storeReporter.infos.clear() compileApp(); - // we should get bad symbolic reference errors, because we're trying to use an implicit that can't be unpickled + // we should get "missing or invalid dependency detected" errors, because we're trying to use an implicit that can't be unpickled // but we don't know the number of these errors and their order, so I just ignore them all - println(filteredInfos.filterNot (_.msg.contains("bad symbolic reference")).mkString("\n")) + println(filteredInfos.filterNot (_.msg.contains("missing or invalid dependency detected")).mkString("\n")) } } From 926585a3f36f35c9afc3f9ed9fe0ded72f6b7014 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Wed, 23 Jul 2014 09:56:24 +0200 Subject: [PATCH 445/826] SI-8743 Fix crasher with poly-methods annotated with @varargs The code that generated the Java varargs forwarder was basing things on the `ValDef-s` of the parameters of the source method. But, their types refer to a type parameter skolems of the enclosing method, which led to a type mismatch when typechecking the forwarder. Instead, I've reworked the code to simply use the `DefDef`-s symbol's info, which *doesn't* refer to skolems. This actually simplifies the surrounding code somewhat; rather than repeated symbols in a map we can just time travel the pre-uncurry method signatures to figure out which params are releated. --- .../scala/tools/nsc/transform/UnCurry.scala | 41 ++++++++----------- .../scala/reflect/internal/TreeInfo.scala | 7 ---- test/files/jvm/varargs.check | 3 +- test/files/jvm/varargs/JavaClass.java | 1 + test/files/jvm/varargs/VaClass.scala | 2 +- test/files/pos/t8743.scala | 15 +++++++ 6 files changed, 35 insertions(+), 34 deletions(-) create mode 100644 test/files/pos/t8743.scala diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala index 2209aac00f87..9b85f1b36ab0 100644 --- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala +++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala @@ -69,7 +69,6 @@ abstract class UnCurry extends InfoTransform private val byNameArgs = mutable.HashSet[Tree]() private val noApply = mutable.HashSet[Tree]() private val newMembers = mutable.Map[Symbol, mutable.Buffer[Tree]]() - private val repeatedParams = mutable.Map[Symbol, List[ValDef]]() /** Add a new synthetic member for `currentOwner` */ private def addNewMember(t: Tree): Unit = @@ -428,7 +427,7 @@ abstract class UnCurry extends InfoTransform treeCopy.ValDef(p, p.mods, p.name, p.tpt, EmptyTree) }) - if (dd.symbol hasAnnotation VarargsClass) saveRepeatedParams(dd) + if (dd.symbol hasAnnotation VarargsClass) validateVarargs(dd) withNeedLift(needLift = false) { if (dd.symbol.isClassConstructor) { @@ -699,19 +698,12 @@ abstract class UnCurry extends InfoTransform } } - - /* Analyzes repeated params if method is annotated as `varargs`. - * If the repeated params exist, it saves them into the `repeatedParams` map, - * which is used later. - */ - private def saveRepeatedParams(dd: DefDef): Unit = + private def validateVarargs(dd: DefDef): Unit = if (dd.symbol.isConstructor) reporter.error(dd.symbol.pos, "A constructor cannot be annotated with a `varargs` annotation.") - else treeInfo.repeatedParams(dd) match { - case Nil => - reporter.error(dd.symbol.pos, "A method without repeated parameters cannot be annotated with the `varargs` annotation.") - case reps => - repeatedParams(dd.symbol) = reps + else { + val hasRepeated = mexists(dd.symbol.paramss)(sym => definitions.isRepeatedParamType(sym.tpe)) + if (!hasRepeated) reporter.error(dd.symbol.pos, "A method without repeated parameters cannot be annotated with the `varargs` annotation.") } /* Called during post transform, after the method argument lists have been flattened. @@ -719,7 +711,7 @@ abstract class UnCurry extends InfoTransform * varargs forwarder. */ private def addJavaVarargsForwarders(dd: DefDef, flatdd: DefDef): DefDef = { - if (!dd.symbol.hasAnnotation(VarargsClass) || !repeatedParams.contains(dd.symbol)) + if (!dd.symbol.hasAnnotation(VarargsClass) || !enteringUncurry(mexists(dd.symbol.paramss)(sym => definitions.isRepeatedParamType(sym.tpe)))) return flatdd def toArrayType(tp: Type): Type = { @@ -735,19 +727,18 @@ abstract class UnCurry extends InfoTransform ) } - val reps = repeatedParams(dd.symbol) - val rpsymbols = reps.map(_.symbol).toSet val theTyper = typer.atOwner(dd, currentClass) - val flatparams = flatdd.vparamss.head + val flatparams = flatdd.symbol.paramss.head + val isRepeated = enteringUncurry(dd.symbol.info.paramss.flatten.map(sym => definitions.isRepeatedParamType(sym.tpe))) // create the type - val forwformals = flatparams map { - case p if rpsymbols(p.symbol) => toArrayType(p.symbol.tpe) - case p => p.symbol.tpe + val forwformals = map2(flatparams, isRepeated) { + case (p, true) => toArrayType(p.tpe) + case (p, false)=> p.tpe } val forwresult = dd.symbol.tpe_*.finalResultType val forwformsyms = map2(forwformals, flatparams)((tp, oldparam) => - currentClass.newValueParameter(oldparam.name, oldparam.symbol.pos).setInfo(tp) + currentClass.newValueParameter(oldparam.name.toTermName, oldparam.pos).setInfo(tp) ) def mono = MethodType(forwformsyms, forwresult) val forwtype = dd.symbol.tpe match { @@ -761,13 +752,13 @@ abstract class UnCurry extends InfoTransform // create the tree val forwtree = theTyper.typedPos(dd.pos) { - val locals = map2(forwParams, flatparams) { - case (_, fp) if !rpsymbols(fp.symbol) => null - case (argsym, fp) => + val locals = map3(forwParams, flatparams, isRepeated) { + case (_, fp, false) => null + case (argsym, fp, true) => Block(Nil, gen.mkCast( gen.mkWrapArray(Ident(argsym), elementType(ArrayClass, argsym.tpe)), - seqType(elementType(SeqClass, fp.symbol.tpe)) + seqType(elementType(SeqClass, fp.tpe)) ) ) } diff --git a/src/reflect/scala/reflect/internal/TreeInfo.scala b/src/reflect/scala/reflect/internal/TreeInfo.scala index b7d7d4df88a5..c521277f69b7 100644 --- a/src/reflect/scala/reflect/internal/TreeInfo.scala +++ b/src/reflect/scala/reflect/internal/TreeInfo.scala @@ -509,13 +509,6 @@ abstract class TreeInfo { case _ => false } - /** The parameter ValDefs of a method definition that have vararg types of the form T* - */ - def repeatedParams(tree: Tree): List[ValDef] = tree match { - case DefDef(_, _, _, vparamss, _, _) => vparamss.flatten filter (vd => isRepeatedParamType(vd.tpt)) - case _ => Nil - } - /** Is tpt a by-name parameter type of the form => T? */ def isByNameParamType(tpt: Tree) = tpt match { case TypeTree() => definitions.isByNameParamType(tpt.tpe) diff --git a/test/files/jvm/varargs.check b/test/files/jvm/varargs.check index 8379befe93aa..986f98896aff 100644 --- a/test/files/jvm/varargs.check +++ b/test/files/jvm/varargs.check @@ -1,3 +1,4 @@ 7 10 -19 \ No newline at end of file +19 +a diff --git a/test/files/jvm/varargs/JavaClass.java b/test/files/jvm/varargs/JavaClass.java index 9851e1b78bca..6928ee5adc4b 100644 --- a/test/files/jvm/varargs/JavaClass.java +++ b/test/files/jvm/varargs/JavaClass.java @@ -11,5 +11,6 @@ public static void callSomeAnnotations() { va.vi(1, 2, 3, 4); varargz(5, 1.0, 2.0, 3.0); va.vt(16, "", "", ""); + System.out.println(va.vt1(16, "a", "b", "c")); } } \ No newline at end of file diff --git a/test/files/jvm/varargs/VaClass.scala b/test/files/jvm/varargs/VaClass.scala index 6343f9c6f677..e94e8a625acd 100644 --- a/test/files/jvm/varargs/VaClass.scala +++ b/test/files/jvm/varargs/VaClass.scala @@ -9,5 +9,5 @@ class VaClass { @varargs def vs(a: Int, b: String*) = println(a + b.length) @varargs def vi(a: Int, b: Int*) = println(a + b.sum) @varargs def vt[T](a: Int, b: T*) = println(a + b.length) - + @varargs def vt1[T](a: Int, b: T*): T = b.head } diff --git a/test/files/pos/t8743.scala b/test/files/pos/t8743.scala new file mode 100644 index 000000000000..03b0cd7044fa --- /dev/null +++ b/test/files/pos/t8743.scala @@ -0,0 +1,15 @@ +import annotation.varargs + +object VarArgs { + @varargs + def foo[A](x: A, xs: String*): A = ??? + + @varargs + def bar[A](x: List[A], xs: String*): A = ??? + + @varargs + def baz[A](x: List[A], xs: String*): A = ??? + + @varargs + def boz[A](x: A, xs: String*): Nothing = ??? +} From ef427b27ac598d890d42991b197aaab06ade580d Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 22 Jul 2014 19:01:01 +0200 Subject: [PATCH 446/826] Bump versions for Scala 2.11.2 --- build.number | 2 +- versions.properties | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/build.number b/build.number index 4a0898529e31..21ce66095854 100644 --- a/build.number +++ b/build.number @@ -1,7 +1,7 @@ #Tue Sep 11 19:21:09 CEST 2007 version.major=2 version.minor=11 -version.patch=2 +version.patch=3 # This is the -N part of a version. if it's 0, it's dropped from maven versions. version.bnum=0 diff --git a/versions.properties b/versions.properties index c334629d2029..cd53a343f6c3 100644 --- a/versions.properties +++ b/versions.properties @@ -1,10 +1,10 @@ -#Tue, 20 May 2014 10:01:37 +0200 +#Wed, 23 Jul 2014 08:37:26 +0200 # NOTE: this file determines the content of the scala-distribution # via scala-dist-pom.xml and scala-library-all-pom.xml # when adding new properties that influence a release, # also add them to the update.versions mechanism in build.xml, # which is used by scala-release-2.11.x in scala/jenkins-scripts -starr.version=2.11.1 +starr.version=2.11.2 starr.use.released=1 # These are the versions of the modules that go with this release. @@ -14,21 +14,21 @@ starr.use.released=1 scala.binary.version=2.11 # e.g. 2.11.0-RC1, 2.11.0, 2.11.1-RC1, 2.11.1 # this defines the dependency on scala-continuations-plugin in scala-dist's pom -scala.full.version=2.11.1 +scala.full.version=2.11.2 # external modules shipped with distribution, as specified by scala-library-all's pom scala-xml.version.number=1.0.2 -scala-parser-combinators.version.number=1.0.1 +scala-parser-combinators.version.number=1.0.2 scala-continuations-plugin.version.number=1.0.2 scala-continuations-library.version.number=1.0.2 scala-swing.version.number=1.0.1 -akka-actor.version.number=2.3.3 +akka-actor.version.number=2.3.4 actors-migration.version.number=1.1.0 jline.version=2.12 # external modules, used internally (not shipped) partest.version.number=1.0.0 -scalacheck.version.number=1.11.3 +scalacheck.version.number=1.11.4 # TODO: modularize the compiler #scala-compiler-doc.version.number=1.0.0-RC1 From 7cca7635b392cb533d0f8e26b74d7362c0dd3891 Mon Sep 17 00:00:00 2001 From: jxcoder Date: Thu, 3 Jul 2014 11:02:49 +0700 Subject: [PATCH 447/826] Refactored example to Option.collect method. --- src/library/scala/Option.scala | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/library/scala/Option.scala b/src/library/scala/Option.scala index d263f89bb8d3..66900e725801 100644 --- a/src/library/scala/Option.scala +++ b/src/library/scala/Option.scala @@ -264,13 +264,13 @@ sealed abstract class Option[+A] extends Product with Serializable { * * @example {{{ * // Returns Some(HTTP) because the partial function covers the case. - * Some("http").collect({case "http" => "HTTP"}) + * Some("http") collect {case "http" => "HTTP"} * * // Returns None because the partial function doesn't cover the case. - * Some("ftp").collect({case "http" => "HTTP"}) + * Some("ftp") collect {case "http" => "HTTP"} * * // Returns None because None is passed to the collect method. - * None.collect({case value => value}) + * None collect {case value => value} * }}} * * @param pf the partial function. From ed9dfee181e56bb83afa0598523786bee5572068 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Tue, 29 Jul 2014 18:12:42 +0200 Subject: [PATCH 448/826] SI-4563 friendlier behavior for Ctrl+D in the REPL Closing the REPL with Ctrl+D does not issue a newline, so the user's prompt displays on the same line as the `scala>` prompt. This is bad. We now force a newline before closing the interpreter, and display `:quit` while we're at it so that people know how to exit the REPL (since `exit` doesn't exist anymore). The tricky part was to only add a newline when the console is interrupted, and *not* when it is closed by a command (like `:quit`), since commands are processed after their text (including newline) has been sent to the console. --- src/compiler/scala/tools/nsc/Properties.scala | 1 + src/repl/scala/tools/nsc/interpreter/ILoop.scala | 9 ++++++++- test/files/jvm/interpreter.check | 2 +- test/files/jvm/throws-annot-from-java.check | 2 +- test/files/jvm/xml05.check | 2 +- test/files/run/class-symbol-contravariant.check | 2 +- test/files/run/constant-type.check | 2 +- test/files/run/constrained-types.check | 2 +- test/files/run/kind-repl-command.check | 2 +- test/files/run/lub-visibility.check | 2 +- test/files/run/macro-bundle-repl.check | 2 +- test/files/run/macro-repl-basic.check | 2 +- test/files/run/macro-repl-dontexpand.check | 2 +- test/files/run/macro-system-properties.check | 2 +- test/files/run/reflection-equality.check | 2 +- test/files/run/reflection-magicsymbols-repl.check | 2 +- test/files/run/reflection-repl-classes.check | 2 +- test/files/run/reflection-repl-elementary.check | 2 +- test/files/run/reify-repl-fail-gracefully.check | 2 +- test/files/run/reify_newimpl_22.check | 2 +- test/files/run/reify_newimpl_23.check | 2 +- test/files/run/reify_newimpl_25.check | 2 +- test/files/run/reify_newimpl_26.check | 2 +- test/files/run/reify_newimpl_35.check | 2 +- test/files/run/repl-assign.check | 2 +- test/files/run/repl-bare-expr.check | 2 +- test/files/run/repl-colon-type.check | 2 +- test/files/run/repl-empty-package.check | 2 +- test/files/run/repl-javap-app.check | 6 +++--- test/files/run/repl-out-dir.check | 2 +- test/files/run/repl-parens.check | 2 +- test/files/run/repl-paste-2.check | 2 +- test/files/run/repl-paste-3.check | 2 +- test/files/run/repl-paste-4.scala | 2 +- test/files/run/repl-paste-raw.scala | 2 +- test/files/run/repl-paste.check | 2 +- test/files/run/repl-power.check | 2 +- test/files/run/repl-reset.check | 2 +- test/files/run/repl-save.scala | 2 +- test/files/run/repl-term-macros.check | 2 +- test/files/run/repl-transcript.check | 2 +- test/files/run/repl-trim-stack-trace.scala | 2 +- test/files/run/repl-type-verbose.check | 2 +- test/files/run/t3376.check | 2 +- test/files/run/t4025.check | 2 +- test/files/run/t4172.check | 2 +- test/files/run/t4216.check | 2 +- test/files/run/t4285.check | 2 +- test/files/run/t4542.check | 2 +- test/files/run/t4594-repl-settings.scala | 2 +- test/files/run/t4671.check | 2 +- test/files/run/t4710.check | 2 +- test/files/run/t5072.check | 2 +- test/files/run/t5256d.check | 2 +- test/files/run/t5535.check | 2 +- test/files/run/t5537.check | 2 +- test/files/run/t5583.check | 2 +- test/files/run/t5655.check | 2 +- test/files/run/t5789.check | 2 +- test/files/run/t6086-repl.check | 2 +- test/files/run/t6146b.check | 2 +- test/files/run/t6187.check | 2 +- test/files/run/t6273.check | 2 +- test/files/run/t6320.check | 2 +- test/files/run/t6329_repl.check | 2 +- test/files/run/t6329_repl_bug.check | 2 +- test/files/run/t6381.check | 2 +- test/files/run/t6434.check | 2 +- test/files/run/t6439.check | 2 +- test/files/run/t6507.check | 2 +- test/files/run/t6549.check | 2 +- test/files/run/t6937.check | 2 +- test/files/run/t7185.check | 2 +- test/files/run/t7319.check | 2 +- test/files/run/t7482a.check | 2 +- test/files/run/t7634.check | 2 +- test/files/run/t7747-repl.check | 2 +- test/files/run/t7801.check | 2 +- test/files/run/t7805-repl-i.check | 2 +- test/files/run/tpeCache-tyconCache.check | 2 +- 80 files changed, 89 insertions(+), 81 deletions(-) diff --git a/src/compiler/scala/tools/nsc/Properties.scala b/src/compiler/scala/tools/nsc/Properties.scala index ed5fda9c3f43..59fefba95493 100644 --- a/src/compiler/scala/tools/nsc/Properties.scala +++ b/src/compiler/scala/tools/nsc/Properties.scala @@ -14,6 +14,7 @@ object Properties extends scala.util.PropertiesTrait { // settings based on jar properties def residentPromptString = scalaPropOrElse("resident.prompt", "\nnsc> ") def shellPromptString = scalaPropOrElse("shell.prompt", "\nscala> ") + def shellInterruptedString = scalaPropOrElse("shell.interrupted", ":quit\n") // derived values def isEmacsShell = propOrEmpty("env.emacs") != "" diff --git a/src/repl/scala/tools/nsc/interpreter/ILoop.scala b/src/repl/scala/tools/nsc/interpreter/ILoop.scala index ce0eadc04ffc..50c89f7442ea 100644 --- a/src/repl/scala/tools/nsc/interpreter/ILoop.scala +++ b/src/repl/scala/tools/nsc/interpreter/ILoop.scala @@ -430,7 +430,14 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) import scala.concurrent.duration._ Await.ready(globalFuture, 60.seconds) - (line ne null) && (command(line) match { + if (line eq null) { + // SI-4563: this means the console was properly interrupted (Ctrl+D usually) + // so we display the output message (which by default ends with + // a newline so as not to break the user's terminal) + if (in.interactive) out.print(Properties.shellInterruptedString) + + false + } else (command(line) match { case Result(false, _) => false case Result(_, Some(line)) => addReplay(line) ; true case _ => true diff --git a/test/files/jvm/interpreter.check b/test/files/jvm/interpreter.check index d124794e72ae..d03edb638c77 100644 --- a/test/files/jvm/interpreter.check +++ b/test/files/jvm/interpreter.check @@ -361,7 +361,7 @@ It would fail on the following inputs: Exp(), Term() ^ f: (e: Exp)Int -scala> +scala> :quit plusOne: (x: Int)Int res0: Int = 6 res0: String = after reset diff --git a/test/files/jvm/throws-annot-from-java.check b/test/files/jvm/throws-annot-from-java.check index be3ba412f891..c541b26fcca3 100644 --- a/test/files/jvm/throws-annot-from-java.check +++ b/test/files/jvm/throws-annot-from-java.check @@ -44,4 +44,4 @@ bar tp.typeParams.isEmpty: true throws[test.PolymorphicException[_]](classOf[test.PolymorphicException]) -scala> +scala> :quit diff --git a/test/files/jvm/xml05.check b/test/files/jvm/xml05.check index 92ea995350d6..cad907525d91 100644 --- a/test/files/jvm/xml05.check +++ b/test/files/jvm/xml05.check @@ -4,4 +4,4 @@ Type :help for more information. scala> res0: scala.xml.Elem = -scala> +scala> :quit diff --git a/test/files/run/class-symbol-contravariant.check b/test/files/run/class-symbol-contravariant.check index 987f215bca4c..cbb90b52c238 100644 --- a/test/files/run/class-symbol-contravariant.check +++ b/test/files/run/class-symbol-contravariant.check @@ -33,4 +33,4 @@ res2: Boolean = true scala> sym.isContravariant // was true res3: Boolean = false -scala> +scala> :quit diff --git a/test/files/run/constant-type.check b/test/files/run/constant-type.check index 77bdf618e69b..a7ba5a46c2a3 100644 --- a/test/files/run/constant-type.check +++ b/test/files/run/constant-type.check @@ -23,4 +23,4 @@ Class[String](classOf[java.lang.String]) scala> { ConstantType(Constant(s)); exitingPhase(currentRun.erasurePhase)(println(ConstantType(Constant(s)))); } Class(classOf[java.lang.String]) -scala> +scala> :quit diff --git a/test/files/run/constrained-types.check b/test/files/run/constrained-types.check index a3cd59b9fbde..89a08d5ccbc8 100644 --- a/test/files/run/constrained-types.check +++ b/test/files/run/constrained-types.check @@ -148,4 +148,4 @@ scala> val x = 3 : Int @Annot(e+f+g+h) // should have a graceful error message val x = 3 : Int @Annot(e+f+g+h) // should have a graceful error message ^ -scala> +scala> :quit diff --git a/test/files/run/kind-repl-command.check b/test/files/run/kind-repl-command.check index 1c292572e68b..586b2710e161 100644 --- a/test/files/run/kind-repl-command.check +++ b/test/files/run/kind-repl-command.check @@ -25,4 +25,4 @@ scala> :k Nonexisting Nonexisting ^ -scala> +scala> :quit diff --git a/test/files/run/lub-visibility.check b/test/files/run/lub-visibility.check index f76579412e20..70734966f0aa 100644 --- a/test/files/run/lub-visibility.check +++ b/test/files/run/lub-visibility.check @@ -8,4 +8,4 @@ scala> // but reverted that for SI-5534. scala> val x = List(List(), Vector()) x: List[scala.collection.immutable.Seq[Nothing] with scala.collection.AbstractSeq[Nothing] with java.io.Serializable] = List(List(), Vector()) -scala> +scala> :quit diff --git a/test/files/run/macro-bundle-repl.check b/test/files/run/macro-bundle-repl.check index 4a0b4216064b..75c5c2addaf2 100644 --- a/test/files/run/macro-bundle-repl.check +++ b/test/files/run/macro-bundle-repl.check @@ -21,4 +21,4 @@ defined term macro foo: Unit scala> foo -scala> +scala> :quit diff --git a/test/files/run/macro-repl-basic.check b/test/files/run/macro-repl-basic.check index 86b4d472ed29..fab03d155833 100644 --- a/test/files/run/macro-repl-basic.check +++ b/test/files/run/macro-repl-basic.check @@ -49,4 +49,4 @@ import Macros.Shmacros._ scala> println(foo(2) + Macros.bar(2) * new Macros().quux(4)) 31 -scala> +scala> :quit diff --git a/test/files/run/macro-repl-dontexpand.check b/test/files/run/macro-repl-dontexpand.check index 20d3b2d702d6..6ecc9245facd 100644 --- a/test/files/run/macro-repl-dontexpand.check +++ b/test/files/run/macro-repl-dontexpand.check @@ -13,4 +13,4 @@ bar2: (c: scala.reflect.macros.whitebox.Context)Nothing scala> def foo2 = macro bar2 defined term macro foo2: Nothing -scala> +scala> :quit diff --git a/test/files/run/macro-system-properties.check b/test/files/run/macro-system-properties.check index ffbd5a8aa881..e2e2bd32b9d3 100644 --- a/test/files/run/macro-system-properties.check +++ b/test/files/run/macro-system-properties.check @@ -19,4 +19,4 @@ defined object Test scala> object Test { class C(implicit a: Any) { GrabContext.grab } } defined object Test -scala> +scala> :quit diff --git a/test/files/run/reflection-equality.check b/test/files/run/reflection-equality.check index 682326bc1882..d60d861a90ec 100644 --- a/test/files/run/reflection-equality.check +++ b/test/files/run/reflection-equality.check @@ -48,4 +48,4 @@ res2: Boolean = true scala> t2 <:< t1 res3: Boolean = true -scala> +scala> :quit diff --git a/test/files/run/reflection-magicsymbols-repl.check b/test/files/run/reflection-magicsymbols-repl.check index 72aef1d3be6b..ca8857ada44e 100644 --- a/test/files/run/reflection-magicsymbols-repl.check +++ b/test/files/run/reflection-magicsymbols-repl.check @@ -34,4 +34,4 @@ scala.Null scala.Nothing scala.Singleton -scala> +scala> :quit diff --git a/test/files/run/reflection-repl-classes.check b/test/files/run/reflection-repl-classes.check index 03a6aef2b553..5ebf993a876d 100644 --- a/test/files/run/reflection-repl-classes.check +++ b/test/files/run/reflection-repl-classes.check @@ -30,4 +30,4 @@ scala> scala> mm(new A) res0: Any = 1 -scala> +scala> :quit diff --git a/test/files/run/reflection-repl-elementary.check b/test/files/run/reflection-repl-elementary.check index 4a223e8a249e..e948c9fd614b 100644 --- a/test/files/run/reflection-repl-elementary.check +++ b/test/files/run/reflection-repl-elementary.check @@ -4,4 +4,4 @@ Type :help for more information. scala> scala.reflect.runtime.universe.typeOf[List[Nothing]] res0: reflect.runtime.universe.Type = scala.List[Nothing] -scala> +scala> :quit diff --git a/test/files/run/reify-repl-fail-gracefully.check b/test/files/run/reify-repl-fail-gracefully.check index 29ccee3cc621..c9e69744d607 100644 --- a/test/files/run/reify-repl-fail-gracefully.check +++ b/test/files/run/reify-repl-fail-gracefully.check @@ -14,4 +14,4 @@ scala> reify reify ^ -scala> +scala> :quit diff --git a/test/files/run/reify_newimpl_22.check b/test/files/run/reify_newimpl_22.check index 1432d10127d1..952f384a1c67 100644 --- a/test/files/run/reify_newimpl_22.check +++ b/test/files/run/reify_newimpl_22.check @@ -22,4 +22,4 @@ scala> { ^ 2 -scala> +scala> :quit diff --git a/test/files/run/reify_newimpl_23.check b/test/files/run/reify_newimpl_23.check index 217f0a98c7b6..b7e9bfdfbc69 100644 --- a/test/files/run/reify_newimpl_23.check +++ b/test/files/run/reify_newimpl_23.check @@ -21,4 +21,4 @@ scala> def foo[T]{ ^ foo: [T]=> Unit -scala> +scala> :quit diff --git a/test/files/run/reify_newimpl_25.check b/test/files/run/reify_newimpl_25.check index 93ad69defa5d..4f36ba10ee15 100644 --- a/test/files/run/reify_newimpl_25.check +++ b/test/files/run/reify_newimpl_25.check @@ -12,4 +12,4 @@ scala> { ^ TypeTag[x.type] -scala> +scala> :quit diff --git a/test/files/run/reify_newimpl_26.check b/test/files/run/reify_newimpl_26.check index 8e0ad87bf28c..681b86279564 100644 --- a/test/files/run/reify_newimpl_26.check +++ b/test/files/run/reify_newimpl_26.check @@ -14,4 +14,4 @@ foo: [T]=> Unit scala> foo[Int] WeakTypeTag[scala.List[T]] -scala> +scala> :quit diff --git a/test/files/run/reify_newimpl_35.check b/test/files/run/reify_newimpl_35.check index f884d2c0d018..bd9b3a2fb1af 100644 --- a/test/files/run/reify_newimpl_35.check +++ b/test/files/run/reify_newimpl_35.check @@ -10,4 +10,4 @@ foo: [T](implicit evidence$1: reflect.runtime.universe.TypeTag[T])reflect.runtim scala> println(foo) Expr[List[Nothing]](Nil) -scala> +scala> :quit diff --git a/test/files/run/repl-assign.check b/test/files/run/repl-assign.check index bdc7793c3776..faa8a93244fe 100644 --- a/test/files/run/repl-assign.check +++ b/test/files/run/repl-assign.check @@ -13,4 +13,4 @@ x: Int = 12 scala> y = 13 y: Int = 13 -scala> +scala> :quit diff --git a/test/files/run/repl-bare-expr.check b/test/files/run/repl-bare-expr.check index 97ae208ff4bc..07cf23412fd3 100644 --- a/test/files/run/repl-bare-expr.check +++ b/test/files/run/repl-bare-expr.check @@ -47,4 +47,4 @@ Bovine.x: List[Any] = List(Ruminant(5), Cow, Moooooo) scala> Bovine.x res4: List[Any] = List(Ruminant(5), Cow, Moooooo) -scala> +scala> :quit diff --git a/test/files/run/repl-colon-type.check b/test/files/run/repl-colon-type.check index 1f6d3e2b3900..9898027c1dd2 100644 --- a/test/files/run/repl-colon-type.check +++ b/test/files/run/repl-colon-type.check @@ -218,4 +218,4 @@ Unit scala> :type println("side effect!") Unit -scala> +scala> :quit diff --git a/test/files/run/repl-empty-package.check b/test/files/run/repl-empty-package.check index ecf79c2c6d69..d3b75f685eeb 100644 --- a/test/files/run/repl-empty-package.check +++ b/test/files/run/repl-empty-package.check @@ -4,4 +4,4 @@ Type :help for more information. scala> println(Bippy.bippy) bippy! -scala> +scala> :quit diff --git a/test/files/run/repl-javap-app.check b/test/files/run/repl-javap-app.check index 1136b415d71f..eb3718f44b0f 100644 --- a/test/files/run/repl-javap-app.check +++ b/test/files/run/repl-javap-app.check @@ -15,7 +15,7 @@ public final void delayedEndpoint$MyApp$1(); Start Length Slot Name Signature 0 9 0 this LMyApp$; -scala> +scala> :quit #partest java7 Welcome to Scala Type in expressions to have them evaluated. @@ -37,7 +37,7 @@ scala> :javap -app MyApp$ line 5: 0 } -scala> +scala> :quit #partest java8 Welcome to Scala Type in expressions to have them evaluated. @@ -60,4 +60,4 @@ scala> :javap -app MyApp$ line 5: 0 } -scala> +scala> :quit diff --git a/test/files/run/repl-out-dir.check b/test/files/run/repl-out-dir.check index 3e51c631559d..c354492898ab 100644 --- a/test/files/run/repl-out-dir.check +++ b/test/files/run/repl-out-dir.check @@ -46,4 +46,4 @@ repl-out-dir-run.obj Test$.class Test.class -scala> +scala> :quit diff --git a/test/files/run/repl-parens.check b/test/files/run/repl-parens.check index 15f4b4524a52..74d15ff93c04 100644 --- a/test/files/run/repl-parens.check +++ b/test/files/run/repl-parens.check @@ -81,4 +81,4 @@ scala> scala> List(1) ++ List('a') res16: List[AnyVal] = List(1, a) -scala> +scala> :quit diff --git a/test/files/run/repl-paste-2.check b/test/files/run/repl-paste-2.check index ab3809a2e0f8..6ea8e2f419b2 100644 --- a/test/files/run/repl-paste-2.check +++ b/test/files/run/repl-paste-2.check @@ -58,4 +58,4 @@ scala> x.length + res5 res3: Int = 129 -scala> +scala> :quit diff --git a/test/files/run/repl-paste-3.check b/test/files/run/repl-paste-3.check index 8fae61792e9a..23e402852fca 100644 --- a/test/files/run/repl-paste-3.check +++ b/test/files/run/repl-paste-3.check @@ -7,4 +7,4 @@ scala> println(3) scala> List(1,2) res1: List[Int] = List(1, 2) -scala> +scala> :quit diff --git a/test/files/run/repl-paste-4.scala b/test/files/run/repl-paste-4.scala index 0060dc1ff6b2..cb0a6aa7682e 100644 --- a/test/files/run/repl-paste-4.scala +++ b/test/files/run/repl-paste-4.scala @@ -14,7 +14,7 @@ s"""|Type in expressions to have them evaluated. |scala> Foo(new Foo) |res0: Int = 7 | - |scala> """ + |scala> :quit""" def pastie = testPath changeExtension "pastie" } diff --git a/test/files/run/repl-paste-raw.scala b/test/files/run/repl-paste-raw.scala index 2953796f99a4..3b41254e9664 100644 --- a/test/files/run/repl-paste-raw.scala +++ b/test/files/run/repl-paste-raw.scala @@ -15,6 +15,6 @@ s"""|Type in expressions to have them evaluated. |scala> favoriteThing.hasString |res0: Boolean = true | - |scala> """ + |scala> :quit""" def pastie = testPath changeExtension "pastie" } diff --git a/test/files/run/repl-paste.check b/test/files/run/repl-paste.check index 97f177ddc498..171447214f21 100644 --- a/test/files/run/repl-paste.check +++ b/test/files/run/repl-paste.check @@ -23,4 +23,4 @@ defined class Dingus defined object Dingus x: Int = 110 -scala> +scala> :quit diff --git a/test/files/run/repl-power.check b/test/files/run/repl-power.check index 8a8ca4601227..e2318c93f2ca 100644 --- a/test/files/run/repl-power.check +++ b/test/files/run/repl-power.check @@ -27,4 +27,4 @@ m: $r.treedsl.global.Literal = 10 scala> typed(m).tpe // typed is in scope res2: $r.treedsl.global.Type = Int(10) -scala> +scala> :quit diff --git a/test/files/run/repl-reset.check b/test/files/run/repl-reset.check index ed95c7b8ffd6..cd7893bbc3ac 100644 --- a/test/files/run/repl-reset.check +++ b/test/files/run/repl-reset.check @@ -54,4 +54,4 @@ defined class BippyBungus scala> { new BippyBungus ; x1 } res2: Int = 4 -scala> +scala> :quit diff --git a/test/files/run/repl-save.scala b/test/files/run/repl-save.scala index 4539790b1a15..c98e6aebc374 100644 --- a/test/files/run/repl-save.scala +++ b/test/files/run/repl-save.scala @@ -16,7 +16,7 @@ s"""|Type in expressions to have them evaluated. | |scala> :save $saveto | - |scala> """ + |scala> :quit""" def saveto = testOutput / "session.repl" override def show() = { super.show() diff --git a/test/files/run/repl-term-macros.check b/test/files/run/repl-term-macros.check index 3580bfe1f116..2cd0b93cd04c 100644 --- a/test/files/run/repl-term-macros.check +++ b/test/files/run/repl-term-macros.check @@ -37,4 +37,4 @@ defined term macro foo3: (x: Int)(y: Int)Unit scala> foo3(2)(3) -scala> +scala> :quit diff --git a/test/files/run/repl-transcript.check b/test/files/run/repl-transcript.check index 49891af90045..b0f106387b55 100644 --- a/test/files/run/repl-transcript.check +++ b/test/files/run/repl-transcript.check @@ -35,4 +35,4 @@ scala> res6.sum + res5 res0: Int = 5273 -scala> +scala> :quit diff --git a/test/files/run/repl-trim-stack-trace.scala b/test/files/run/repl-trim-stack-trace.scala index 483659146a86..a53ce3b3e4e9 100644 --- a/test/files/run/repl-trim-stack-trace.scala +++ b/test/files/run/repl-trim-stack-trace.scala @@ -32,7 +32,7 @@ java.lang.Exception at .f(:7) ... 69 elided -scala> """ +scala> :quit""" // normalize the "elided" lines because the frame count depends on test context lazy val elided = """(\s+\.{3} )\d+( elided)""".r diff --git a/test/files/run/repl-type-verbose.check b/test/files/run/repl-type-verbose.check index e37754a06068..6f6b47b86dda 100644 --- a/test/files/run/repl-type-verbose.check +++ b/test/files/run/repl-type-verbose.check @@ -187,4 +187,4 @@ PolyType( ) ) -scala> +scala> :quit diff --git a/test/files/run/t3376.check b/test/files/run/t3376.check index cc6949d3262a..b8fd2843f6a2 100644 --- a/test/files/run/t3376.check +++ b/test/files/run/t3376.check @@ -13,4 +13,4 @@ m2: M[Float] = mmm scala> val m3 = new M[String]() m3: M[String] = mmm -scala> +scala> :quit diff --git a/test/files/run/t4025.check b/test/files/run/t4025.check index 2d4f644c5aae..e8c6851236f1 100644 --- a/test/files/run/t4025.check +++ b/test/files/run/t4025.check @@ -14,4 +14,4 @@ scala> scala> def f(c: Any) = c match { case Red(_) => () } f: (c: Any)Unit -scala> +scala> :quit diff --git a/test/files/run/t4172.check b/test/files/run/t4172.check index a748430e2ee3..315c1c9dbdd5 100644 --- a/test/files/run/t4172.check +++ b/test/files/run/t4172.check @@ -5,4 +5,4 @@ scala> val c = { class C { override def toString = "C" }; ((new C, new C { def f warning: there was one feature warning; re-run with -feature for details c: (C, C{def f: Int}) forSome { type C <: AnyRef } = (C,C) -scala> +scala> :quit diff --git a/test/files/run/t4216.check b/test/files/run/t4216.check index 091e55a0c7b2..e4610e87d3be 100644 --- a/test/files/run/t4216.check +++ b/test/files/run/t4216.check @@ -34,4 +34,4 @@ res4: java.util.List[V] = [V@0] scala> o(new V(0)) res5: java.util.List[Any] = [V@0] -scala> +scala> :quit diff --git a/test/files/run/t4285.check b/test/files/run/t4285.check index 314c8e5a3516..b952cb8e1b58 100644 --- a/test/files/run/t4285.check +++ b/test/files/run/t4285.check @@ -10,4 +10,4 @@ y: scala.collection.mutable.WrappedArray[Int] = WrappedArray(2, 4, 6, 8, 10, 12, scala> println(y.sum) 56 -scala> +scala> :quit diff --git a/test/files/run/t4542.check b/test/files/run/t4542.check index a53f31a3c762..f7716dc2f0c4 100644 --- a/test/files/run/t4542.check +++ b/test/files/run/t4542.check @@ -12,4 +12,4 @@ scala> val f = new Foo ^ f: Foo = Bippy -scala> +scala> :quit diff --git a/test/files/run/t4594-repl-settings.scala b/test/files/run/t4594-repl-settings.scala index 8b8b2e3746eb..4202991607d2 100644 --- a/test/files/run/t4594-repl-settings.scala +++ b/test/files/run/t4594-repl-settings.scala @@ -22,5 +22,5 @@ object Test extends SessionTest { | ^ |b: String | - |scala> """ + |scala> :quit""" } diff --git a/test/files/run/t4671.check b/test/files/run/t4671.check index 0c36083759d5..1640dac8e49c 100644 --- a/test/files/run/t4671.check +++ b/test/files/run/t4671.check @@ -43,4 +43,4 @@ println(s.mkString("")) } -scala> +scala> :quit diff --git a/test/files/run/t4710.check b/test/files/run/t4710.check index 6ee7198b4b5a..0dd49dfbd312 100644 --- a/test/files/run/t4710.check +++ b/test/files/run/t4710.check @@ -5,4 +5,4 @@ scala> def method : String = { implicit def f(s: Symbol) = "" ; 'symbol } warning: there was one feature warning; re-run with -feature for details method: String -scala> +scala> :quit diff --git a/test/files/run/t5072.check b/test/files/run/t5072.check index ddd49c71cb3c..ab34e49869da 100644 --- a/test/files/run/t5072.check +++ b/test/files/run/t5072.check @@ -7,4 +7,4 @@ defined class C scala> Thread.currentThread.getContextClassLoader.loadClass(classOf[C].getName) res0: Class[_] = class C -scala> +scala> :quit diff --git a/test/files/run/t5256d.check b/test/files/run/t5256d.check index d42d234386d1..c2b49989abaf 100644 --- a/test/files/run/t5256d.check +++ b/test/files/run/t5256d.check @@ -25,4 +25,4 @@ scala.AnyRef { def foo: scala.Nothing } -scala> +scala> :quit diff --git a/test/files/run/t5535.check b/test/files/run/t5535.check index a0c87a47f43f..84097ccea900 100644 --- a/test/files/run/t5535.check +++ b/test/files/run/t5535.check @@ -13,4 +13,4 @@ f: Int => Int = scala> println(f(10)) 11 -scala> +scala> :quit diff --git a/test/files/run/t5537.check b/test/files/run/t5537.check index b9d521f301f7..98265ccc9228 100644 --- a/test/files/run/t5537.check +++ b/test/files/run/t5537.check @@ -13,4 +13,4 @@ res2: List[scala.collection.immutable.List.type] = List() scala> List[Set.type]() res3: List[Set.type] = List() -scala> +scala> :quit diff --git a/test/files/run/t5583.check b/test/files/run/t5583.check index af96405bddc0..32d285cbb373 100644 --- a/test/files/run/t5583.check +++ b/test/files/run/t5583.check @@ -13,4 +13,4 @@ scala> for (i <- 1 to 10) {s += i} scala> println(s) 165 -scala> +scala> :quit diff --git a/test/files/run/t5655.check b/test/files/run/t5655.check index 06c6b32599ce..4bbc54b64124 100644 --- a/test/files/run/t5655.check +++ b/test/files/run/t5655.check @@ -23,4 +23,4 @@ and import x x ^ -scala> +scala> :quit diff --git a/test/files/run/t5789.check b/test/files/run/t5789.check index bcb2382559fe..193abfaff028 100644 --- a/test/files/run/t5789.check +++ b/test/files/run/t5789.check @@ -7,4 +7,4 @@ n: Int = 2 scala> () => n res0: () => Int = -scala> +scala> :quit diff --git a/test/files/run/t6086-repl.check b/test/files/run/t6086-repl.check index 115eff5f8511..b904f118e8df 100644 --- a/test/files/run/t6086-repl.check +++ b/test/files/run/t6086-repl.check @@ -7,4 +7,4 @@ defined class X scala> scala.reflect.runtime.universe.typeOf[X] res0: reflect.runtime.universe.Type = X -scala> +scala> :quit diff --git a/test/files/run/t6146b.check b/test/files/run/t6146b.check index a3b09efcd9e3..6998873fb7ca 100644 --- a/test/files/run/t6146b.check +++ b/test/files/run/t6146b.check @@ -60,4 +60,4 @@ res2: u.Type = O.S3 scala> memType(S4, fTpe) res3: u.Type = S4 -scala> +scala> :quit diff --git a/test/files/run/t6187.check b/test/files/run/t6187.check index 01801258092c..9a9e266ec6a3 100644 --- a/test/files/run/t6187.check +++ b/test/files/run/t6187.check @@ -29,4 +29,4 @@ res1: List[Int] = List(1) scala> List("") collect { case x => x } res2: List[String] = List("") -scala> +scala> :quit diff --git a/test/files/run/t6273.check b/test/files/run/t6273.check index bef0b227d20c..3b682800df4d 100644 --- a/test/files/run/t6273.check +++ b/test/files/run/t6273.check @@ -12,4 +12,4 @@ x: String = y = 55 " -scala> +scala> :quit diff --git a/test/files/run/t6320.check b/test/files/run/t6320.check index 013acc1c54ac..af7c865690ce 100644 --- a/test/files/run/t6320.check +++ b/test/files/run/t6320.check @@ -10,4 +10,4 @@ defined class Dyn scala> new Dyn(Map("foo" -> 10)).foo[Int] res0: Int = 10 -scala> +scala> :quit diff --git a/test/files/run/t6329_repl.check b/test/files/run/t6329_repl.check index ad0bb46e5bc5..ebb1aace7c65 100644 --- a/test/files/run/t6329_repl.check +++ b/test/files/run/t6329_repl.check @@ -32,4 +32,4 @@ res6: scala.reflect.ClassTag[scala.collection.immutable.Set[_]] = scala.collecti scala> classTag[scala.collection.immutable.Set[_]] res7: scala.reflect.ClassTag[scala.collection.immutable.Set[_]] = scala.collection.immutable.Set -scala> +scala> :quit diff --git a/test/files/run/t6329_repl_bug.check b/test/files/run/t6329_repl_bug.check index 38a8de56065c..84297a629f54 100644 --- a/test/files/run/t6329_repl_bug.check +++ b/test/files/run/t6329_repl_bug.check @@ -14,4 +14,4 @@ res0: scala.reflect.ClassTag[List[_]] = scala.collection.immutable.List[] scala> scala.reflect.classTag[List[_]] res1: scala.reflect.ClassTag[List[_]] = scala.collection.immutable.List -scala> +scala> :quit diff --git a/test/files/run/t6381.check b/test/files/run/t6381.check index 4ed11d59ff6c..49c6a784ad51 100644 --- a/test/files/run/t6381.check +++ b/test/files/run/t6381.check @@ -16,4 +16,4 @@ defined term macro pos: String scala> pos res0: String = class scala.reflect.internal.util.RangePosition -scala> +scala> :quit diff --git a/test/files/run/t6434.check b/test/files/run/t6434.check index f898b6b781fb..0a75ae2bd53a 100644 --- a/test/files/run/t6434.check +++ b/test/files/run/t6434.check @@ -7,4 +7,4 @@ f: (x: => Int)Int scala> f _ res0: (=> Int) => Int = -scala> +scala> :quit diff --git a/test/files/run/t6439.check b/test/files/run/t6439.check index f8d5b3a8cde1..c4b75910696f 100644 --- a/test/files/run/t6439.check +++ b/test/files/run/t6439.check @@ -70,4 +70,4 @@ defined object lookup scala> lookup("F") // this now works as a result of changing .typeSymbol to .typeSymbolDirect in IMain#Request#definedSymbols res0: $r.intp.global.Symbol = type F -scala> +scala> :quit diff --git a/test/files/run/t6507.check b/test/files/run/t6507.check index 3536c4238133..5da4aa3a24d5 100644 --- a/test/files/run/t6507.check +++ b/test/files/run/t6507.check @@ -21,4 +21,4 @@ scala> res0 ! res1: A = A -scala> +scala> :quit diff --git a/test/files/run/t6549.check b/test/files/run/t6549.check index d5dfc5ebe8a5..be3445927e99 100644 --- a/test/files/run/t6549.check +++ b/test/files/run/t6549.check @@ -25,4 +25,4 @@ m(scala.Symbol("s")).xxx: Any = 's scala> val `"` = 0 ": Int = 0 -scala> +scala> :quit diff --git a/test/files/run/t6937.check b/test/files/run/t6937.check index 4729dc700664..5c5d4485b6a7 100644 --- a/test/files/run/t6937.check +++ b/test/files/run/t6937.check @@ -19,4 +19,4 @@ apiru: scala.reflect.api.Universe = scala> apiru.typeTag[A].in(cm) res0: reflect.runtime.universe.TypeTag[A] = TypeTag[A] -scala> +scala> :quit diff --git a/test/files/run/t7185.check b/test/files/run/t7185.check index ebf85b731f9f..e4f80a8ff957 100644 --- a/test/files/run/t7185.check +++ b/test/files/run/t7185.check @@ -29,4 +29,4 @@ res0: Any = } } -scala> +scala> :quit diff --git a/test/files/run/t7319.check b/test/files/run/t7319.check index 2ac414209865..e35cfc90c099 100644 --- a/test/files/run/t7319.check +++ b/test/files/run/t7319.check @@ -40,4 +40,4 @@ scala> Range(1,2).toArray: Seq[_] scala> 0 res2: Int = 0 -scala> +scala> :quit diff --git a/test/files/run/t7482a.check b/test/files/run/t7482a.check index 943538f352af..a21ef7b68fb4 100644 --- a/test/files/run/t7482a.check +++ b/test/files/run/t7482a.check @@ -7,4 +7,4 @@ v: java.util.ArrayList[String] = [] scala> val v: java.util.ArrayList[String] = new java.util.ArrayList[String](5) v: java.util.ArrayList[String] = [] -scala> +scala> :quit diff --git a/test/files/run/t7634.check b/test/files/run/t7634.check index aea3b94da57c..9c6b8b47ddc6 100644 --- a/test/files/run/t7634.check +++ b/test/files/run/t7634.check @@ -5,4 +5,4 @@ Type :help for more information. scala> .lines res1: List[String] = List(shello, world.) -scala> +scala> :quit diff --git a/test/files/run/t7747-repl.check b/test/files/run/t7747-repl.check index ad924f482ceb..105b238d01d6 100644 --- a/test/files/run/t7747-repl.check +++ b/test/files/run/t7747-repl.check @@ -283,4 +283,4 @@ object $read extends $read { } res3: List[Product with Serializable] = List(BippyBups(), PuppyPups(), Bingo()) -scala> +scala> :quit diff --git a/test/files/run/t7801.check b/test/files/run/t7801.check index d72060c684f5..e0b656b78420 100644 --- a/test/files/run/t7801.check +++ b/test/files/run/t7801.check @@ -8,4 +8,4 @@ import g.abort scala> class C(val a: Any) extends AnyVal defined class C -scala> +scala> :quit diff --git a/test/files/run/t7805-repl-i.check b/test/files/run/t7805-repl-i.check index eecfff079a9b..7f66c06a111a 100644 --- a/test/files/run/t7805-repl-i.check +++ b/test/files/run/t7805-repl-i.check @@ -8,4 +8,4 @@ Type :help for more information. scala> Console println Try(8) Success(8) -scala> +scala> :quit diff --git a/test/files/run/tpeCache-tyconCache.check b/test/files/run/tpeCache-tyconCache.check index a892f5477aad..ff604819e0c3 100644 --- a/test/files/run/tpeCache-tyconCache.check +++ b/test/files/run/tpeCache-tyconCache.check @@ -16,4 +16,4 @@ res0: Boolean = true scala> AnyRefClass.tpe eq AnyRefClass.typeConstructor res1: Boolean = true -scala> +scala> :quit From 262b0b251753f882266b969d4716d097ceb8fb3c Mon Sep 17 00:00:00 2001 From: Kato Kazuyoshi Date: Sun, 27 Jul 2014 16:38:51 +0900 Subject: [PATCH 449/826] Prevent SI-7905 by adding a test The original issue was fixed already. This test is just for make sure. --- test/scaladoc/run/t7905.check | 1 + test/scaladoc/run/t7905.scala | 36 +++++++++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+) create mode 100644 test/scaladoc/run/t7905.check create mode 100644 test/scaladoc/run/t7905.scala diff --git a/test/scaladoc/run/t7905.check b/test/scaladoc/run/t7905.check new file mode 100644 index 000000000000..619c56180bb9 --- /dev/null +++ b/test/scaladoc/run/t7905.check @@ -0,0 +1 @@ +Done. diff --git a/test/scaladoc/run/t7905.scala b/test/scaladoc/run/t7905.scala new file mode 100644 index 000000000000..857072447036 --- /dev/null +++ b/test/scaladoc/run/t7905.scala @@ -0,0 +1,36 @@ +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocModelTest + +object Test extends ScaladocModelTest { + override def code = """ + object A { + val foo = new B { + val bar = new C { + val baz: A.this.type = A.this + } + } + } + + trait B { + type E = bar.D + + val bar: C + } + + trait C { + trait D + } + + trait G { + type F = A.foo.E + + def m(f: F) = f match { + case _: A.foo.bar.D => // error here + } + } + """ + + def scaladocSettings = "" + + def testModel(root: Package) = () +} From b6c00d6e121c3421030a82d6322290c3c4962c81 Mon Sep 17 00:00:00 2001 From: Kato Kazuyoshi Date: Sun, 27 Jul 2014 09:40:03 +0900 Subject: [PATCH 450/826] Prevent SI-8314 by adding a test The original issue was fixed already. This test is just for make sure. --- test/scaladoc/run/t8314.check | 3 +++ test/scaladoc/run/t8314.scala | 16 ++++++++++++++++ 2 files changed, 19 insertions(+) create mode 100644 test/scaladoc/run/t8314.check create mode 100644 test/scaladoc/run/t8314.scala diff --git a/test/scaladoc/run/t8314.check b/test/scaladoc/run/t8314.check new file mode 100644 index 000000000000..aa04c12c8ffd --- /dev/null +++ b/test/scaladoc/run/t8314.check @@ -0,0 +1,3 @@ +Body(List(Paragraph(Chain(List(Summary(Chain(List(Text(This should be ), Monospace(Text(monospaced)))))))))) + +Done. diff --git a/test/scaladoc/run/t8314.scala b/test/scaladoc/run/t8314.scala new file mode 100644 index 000000000000..7f6d6fdb0024 --- /dev/null +++ b/test/scaladoc/run/t8314.scala @@ -0,0 +1,16 @@ +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocModelTest + +object Test extends ScaladocModelTest { + override def code = """ + /** This should be `monospaced` */ + class A + """ + + def scaladocSettings = "" + + def testModel(root: Package) = { + import access._ + root._class("A").comment foreach println + } +} From bb2c24646eb8001d0efeff354c50127e47716ec8 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Thu, 31 Jul 2014 18:31:15 +0200 Subject: [PATCH 451/826] a few missing deprecations in proxy collections. SeqProxy was properly deprecated, so were the CollProxyLike classes, and the ones in collection.immutable, but these four somehow survived the Big Proxy Deprecation (tm). --- src/library/scala/collection/IterableProxy.scala | 1 + src/library/scala/collection/MapProxy.scala | 1 + src/library/scala/collection/SetProxy.scala | 1 + src/library/scala/collection/TraversableProxy.scala | 1 + 4 files changed, 4 insertions(+) diff --git a/src/library/scala/collection/IterableProxy.scala b/src/library/scala/collection/IterableProxy.scala index 3a0e2ab1158e..97aa830c5a0b 100644 --- a/src/library/scala/collection/IterableProxy.scala +++ b/src/library/scala/collection/IterableProxy.scala @@ -16,4 +16,5 @@ package collection * @version 2.8 * @since 2.8 */ +@deprecated("Proxying is deprecated due to lack of use and compiler-level support.", "2.11.3") trait IterableProxy[+A] extends Iterable[A] with IterableProxyLike[A, Iterable[A]] diff --git a/src/library/scala/collection/MapProxy.scala b/src/library/scala/collection/MapProxy.scala index 941c1f5a4a43..26a7c710ee43 100644 --- a/src/library/scala/collection/MapProxy.scala +++ b/src/library/scala/collection/MapProxy.scala @@ -17,4 +17,5 @@ package collection * @version 1.0, 21/07/2003 * @since 1 */ +@deprecated("Proxying is deprecated due to lack of use and compiler-level support.", "2.11.3") trait MapProxy[A, +B] extends Map[A, B] with MapProxyLike[A, B, Map[A, B]] diff --git a/src/library/scala/collection/SetProxy.scala b/src/library/scala/collection/SetProxy.scala index f9f38f148a66..e17fb215b972 100644 --- a/src/library/scala/collection/SetProxy.scala +++ b/src/library/scala/collection/SetProxy.scala @@ -17,4 +17,5 @@ package collection * @author Martin Odersky * @version 2.0, 01/01/2007 */ +@deprecated("Proxying is deprecated due to lack of use and compiler-level support.", "2.11.3") trait SetProxy[A] extends Set[A] with SetProxyLike[A, Set[A]] diff --git a/src/library/scala/collection/TraversableProxy.scala b/src/library/scala/collection/TraversableProxy.scala index 65936da0e4ba..9eec685d101d 100644 --- a/src/library/scala/collection/TraversableProxy.scala +++ b/src/library/scala/collection/TraversableProxy.scala @@ -21,4 +21,5 @@ package collection * @version 2.8 * @since 2.8 */ +@deprecated("Proxying is deprecated due to lack of use and compiler-level support.", "2.11.3") trait TraversableProxy[+A] extends Traversable[A] with TraversableProxyLike[A, Traversable[A]] From 199ae261445b28d46d2b900b90947f75de0b1999 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Sun, 3 Aug 2014 21:45:38 -0700 Subject: [PATCH 452/826] Orphan check file Orphaned by the override check reversion that deleted the test source. 2524fdde3edc7b668fdb4bf68e990141d3ec18d6 --- test/files/run/private-override.check | 1 - 1 file changed, 1 deletion(-) delete mode 100644 test/files/run/private-override.check diff --git a/test/files/run/private-override.check b/test/files/run/private-override.check deleted file mode 100644 index 00750edc07d6..000000000000 --- a/test/files/run/private-override.check +++ /dev/null @@ -1 +0,0 @@ -3 From e131424b45881ac8446235f255c8f637602857ac Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Sun, 27 Jul 2014 15:24:46 +0200 Subject: [PATCH 453/826] Work around weird AbstractMethodError Could not figure it out, so resorting to brain dumping. something with private classes and defaults, the default getter will be in the private companion module, but there's no accessor to get the module??? maybe something related to make non-private of the accessor? while running the repl or, e.g., the test presentation/ide-t1000567 AbstractMethodError: scala.tools.nsc.interactive.Global$$anon$5.scala$tools$nsc$typechecker$Contexts$$BufferingReporter()Lscala/tools/nsc/typechecker/Contexts$BufferingReporter$; at scala.tools.nsc.typechecker.Contexts$Context.makeSilent(Contexts.scala:518) in progress minimal repro: ``` package a class Reporter class Global { lazy val analyzer = new { val global: Global.this.type = Global.this } with Analyzer } trait Analyzer extends AnyRef with Contexts { val global : Global } trait Contexts { self: Analyzer => // the accessor to get to ContextReporter's companion object // to get the default for x is not emitted for some reason // the expected accessor is the non-private version // `def scala$tools$nsc$typechecker$Contexts$$BufferingReporter: scala.tools.nsc.typechecker.Contexts#BufferingReporter$` // (as seen in the AbstractMethodError's message) abstract class ContextReporter(x: Any = null) extends Reporter private class ThrowingReporter extends ContextReporter class Context(a: Any, private[this] var _reporter: ContextReporter = new ThrowingReporter) { def reporter = _reporter } object NoContext extends Context(null) } package b trait ReplGlobal extends a.Global { // this anon class corresponds to scala.tools.nsc.interactive.Global$$anon$5 in the above AbstractMethodError override lazy val analyzer = new { val global: ReplGlobal.this.type = ReplGlobal.this } with a.Analyzer { } } ``` --- src/compiler/scala/tools/nsc/typechecker/Contexts.scala | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index fd9d1de88ee1..6573102e860d 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -1312,13 +1312,13 @@ trait Contexts { self: Analyzer => final def clearAllWarnings(): Unit = warningBuffer.clear() } - private class ImmediateReporter(_errorBuffer: mutable.LinkedHashSet[AbsTypeError] = null, _warningBuffer: mutable.LinkedHashSet[(Position, String)] = null) extends ContextReporter(_errorBuffer, _warningBuffer) { + private[typechecker] class ImmediateReporter(_errorBuffer: mutable.LinkedHashSet[AbsTypeError] = null, _warningBuffer: mutable.LinkedHashSet[(Position, String)] = null) extends ContextReporter(_errorBuffer, _warningBuffer) { override def makeBuffering: ContextReporter = new BufferingReporter(errorBuffer, warningBuffer) protected def handleError(pos: Position, msg: String): Unit = reporter.error(pos, msg) } - private class BufferingReporter(_errorBuffer: mutable.LinkedHashSet[AbsTypeError] = null, _warningBuffer: mutable.LinkedHashSet[(Position, String)] = null) extends ContextReporter(_errorBuffer, _warningBuffer) { + private[typechecker] class BufferingReporter(_errorBuffer: mutable.LinkedHashSet[AbsTypeError] = null, _warningBuffer: mutable.LinkedHashSet[(Position, String)] = null) extends ContextReporter(_errorBuffer, _warningBuffer) { override def isBuffering = true override def issue(err: AbsTypeError)(implicit context: Context): Unit = errorBuffer += err @@ -1337,12 +1337,12 @@ trait Contexts { self: Analyzer => * * TODO: get rid of it, use ImmediateReporter and a check for reporter.hasErrors where necessary */ - private class ThrowingReporter extends ContextReporter { + private[typechecker] class ThrowingReporter extends ContextReporter { protected def handleError(pos: Position, msg: String): Unit = throw new TypeError(pos, msg) } /** Used during a run of [[scala.tools.nsc.typechecker.TreeCheckers]]? */ - private class CheckingReporter extends ContextReporter { + private[typechecker] class CheckingReporter extends ContextReporter { protected def handleError(pos: Position, msg: String): Unit = onTreeCheckerError(pos, msg) } From 3a4c6db9fe8c06b78f907f182e80e908c653cf89 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Wed, 23 Jul 2014 23:30:52 +0200 Subject: [PATCH 454/826] Towards more privacy for _reporter. Move code that manipulates the error buffers / reporters into combinators in Context/ContextReporter. Eventually, would like to statically know when we're in silent mode, and only then use buffering (push buffering code down to BufferingReporter). Simplify TryTwice; avoid capturing mutable var in closure. Changed inSilentMode to no longer check `&& !reporter.hasErrors`; disassembling optimized code showed that this was keeping the inliner from inlining this method. Introduce a couple more combinators: - withFreshErrorBuffer - propagatingErrorsTo - propagateImplicitTypeErrorsTo --- .../tools/nsc/typechecker/Contexts.scala | 180 +++++++++++------- .../tools/nsc/typechecker/Implicits.scala | 11 +- .../scala/tools/nsc/typechecker/Infer.scala | 14 +- .../scala/tools/nsc/typechecker/Typers.scala | 33 +--- 4 files changed, 130 insertions(+), 108 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala index 6573102e860d..a79f162140a7 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala @@ -182,7 +182,8 @@ trait Contexts { self: Analyzer => * @param _outer The next outer context. */ class Context private[typechecker](val tree: Tree, val owner: Symbol, val scope: Scope, - val unit: CompilationUnit, _outer: Context) { + val unit: CompilationUnit, _outer: Context, + private[this] var _reporter: ContextReporter = new ThrowingReporter) { private def outerIsNoContext = _outer eq null final def outer: Context = if (outerIsNoContext) NoContext else _outer @@ -325,59 +326,50 @@ trait Contexts { self: Analyzer => // // the reporter for this context - // TODO: start off with ImmediateReporter - private var _reporter: ContextReporter = new ThrowingReporter - - def reporter = _reporter + def reporter: ContextReporter = _reporter // if set, errors will not be reporter/thrown - def bufferErrors = reporter.isBuffering - def reportErrors = !bufferErrors + def bufferErrors = reporter.isBuffering + def reportErrors = !bufferErrors // whether to *report* (which is separate from buffering/throwing) ambiguity errors def ambiguousErrors = this(AmbiguousErrors) private def setAmbiguousErrors(report: Boolean): Unit = this(AmbiguousErrors) = report - /** - * Try inference twice, once without views and once with views, + * Try inference twice: once without views and once with views, * unless views are already disabled. */ abstract class TryTwice { def tryOnce(isLastTry: Boolean): Unit - def apply(): Unit = { - var doLastTry = !implicitsEnabled - - // do first try if implicits are enabled - if (implicitsEnabled) { - val savedReporter = _reporter - val savedContextMode = contextMode - - _reporter = new BufferingReporter - setAmbiguousErrors(false) // this means ambiguous errors will not be force-fed to the reporter - - // We create a new BufferingReporter to - // distinguish errors that occurred before entering tryTwice - // and our first attempt in 'withImplicitsDisabled'. If the - // first attempt fails, we try with implicits on - // and the original reporter. - try { - withImplicitsDisabled(tryOnce(false)) - doLastTry = reporter.hasErrors - } catch { - case ex: CyclicReference => throw ex - case ex: TypeError => doLastTry = true // recoverable cyclic references? - } finally { - contextMode = savedContextMode - _reporter = savedReporter - } - } + final def apply(): Unit = { + val doLastTry = + // do first try if implicits are enabled + if (implicitsEnabled) { + // We create a new BufferingReporter to + // distinguish errors that occurred before entering tryTwice + // and our first attempt in 'withImplicitsDisabled'. If the + // first attempt fails, we try with implicits on + // and the original reporter. + // immediate reporting of ambiguous errors is suppressed, so that they are buffered + inSilentMode { + try { + set(disable = ImplicitsEnabled | EnrichmentEnabled) // restored by inSilentMode + tryOnce(false) + reporter.hasErrors + } catch { + case ex: CyclicReference => throw ex + case ex: TypeError => true // recoverable cyclic references? + } + } + } else true // do last try if try with implicits enabled failed // (or if it was not attempted because they were disabled) - if (doLastTry) tryOnce(true) + if (doLastTry) + tryOnce(true) } } @@ -385,7 +377,7 @@ trait Contexts { self: Analyzer => // Temporary mode adjustment // - @inline def withMode[T](enabled: ContextMode = NOmode, disabled: ContextMode = NOmode)(op: => T): T = { + @inline final def withMode[T](enabled: ContextMode = NOmode, disabled: ContextMode = NOmode)(op: => T): T = { val saved = contextMode set(enabled, disabled) try op @@ -419,17 +411,18 @@ trait Contexts { self: Analyzer => // See comment on FormerNonStickyModes. @inline final def withOnlyStickyModes[T](op: => T): T = withMode(disabled = FormerNonStickyModes)(op) - /** @return true if the `expr` evaluates to true within a silent Context that incurs no errors */ + // inliner note: this has to be a simple method for inlining to work -- moved the `&& !reporter.hasErrors` out @inline final def inSilentMode(expr: => Boolean): Boolean = { - val savedReporter = _reporter - withMode() { // TODO: rework -- withMode with no arguments to restore the mode mutated by `setBufferErrors` (no longer mutated!) - _reporter = reporter.makeBuffering - setAmbiguousErrors(false) - try expr && !reporter.hasErrors - finally { - _reporter = savedReporter - _reporter.clearAll() // TODO: ??? - } + val savedContextMode = contextMode + val savedReporter = reporter + + setAmbiguousErrors(false) + _reporter = new BufferingReporter + + try expr + finally { + contextMode = savedContextMode + _reporter = savedReporter } } @@ -445,7 +438,8 @@ trait Contexts { self: Analyzer => * `Context#imports`. */ def make(tree: Tree = tree, owner: Symbol = owner, - scope: Scope = scope, unit: CompilationUnit = unit): Context = { + scope: Scope = scope, unit: CompilationUnit = unit, + reporter: ContextReporter = this.reporter): Context = { val isTemplateOrPackage = tree match { case _: Template | _: PackageDef => true case _ => false @@ -468,16 +462,15 @@ trait Contexts { self: Analyzer => // The blank canvas val c = if (isImport) - new Context(tree, owner, scope, unit, this) with ImportContext + new Context(tree, owner, scope, unit, this, reporter) with ImportContext else - new Context(tree, owner, scope, unit, this) + new Context(tree, owner, scope, unit, this, reporter) // Fields that are directly propagated c.variance = variance c.diagUsedDefaults = diagUsedDefaults c.openImplicits = openImplicits c.contextMode = contextMode // note: ConstructorSuffix, a bit within `mode`, is conditionally overwritten below. - c._reporter = reporter // Fields that may take on a different value in the child c.prefix = prefixInChild @@ -510,22 +503,19 @@ trait Contexts { self: Analyzer => else make(tree, owner, scope, unit) /** Make a child context that represents a new nested scope */ - def makeNewScope(tree: Tree, owner: Symbol): Context = - make(tree, owner, newNestedScope(scope)) - + def makeNewScope(tree: Tree, owner: Symbol, reporter: ContextReporter = this.reporter): Context = + make(tree, owner, newNestedScope(scope), reporter = reporter) /** Make a child context that buffers errors and warnings into a fresh report buffer. */ def makeSilent(reportAmbiguousErrors: Boolean = ambiguousErrors, newtree: Tree = tree): Context = { - val c = make(newtree) - c.setAmbiguousErrors(reportAmbiguousErrors) // A fresh buffer so as not to leak errors/warnings into `this`. - c._reporter = new BufferingReporter + val c = make(newtree, reporter = new BufferingReporter) + c.setAmbiguousErrors(reportAmbiguousErrors) c } def makeNonSilent(newtree: Tree): Context = { - val c = make(newtree) - c._reporter = reporter.makeImmediate + val c = make(newtree, reporter = reporter.makeImmediate) c.setAmbiguousErrors(true) c } @@ -549,9 +539,10 @@ trait Contexts { self: Analyzer => */ def makeConstructorContext = { val baseContext = enclClass.outer.nextEnclosing(!_.tree.isInstanceOf[Template]) - val argContext = baseContext.makeNewScope(tree, owner) + // must propagate reporter! + // (caught by neg/t3649 when refactoring reporting to be specified only by this.reporter and not also by this.contextMode) + val argContext = baseContext.makeNewScope(tree, owner, reporter = this.reporter) argContext.contextMode = contextMode - argContext._reporter = _reporter // caught by neg/t3649 TODO: make sure _reporter is propagated wherever contextMode is argContext.inSelfSuperCall = true def enterElems(c: Context) { def enterLocalElems(e: ScopeEntry) { @@ -1230,7 +1221,17 @@ trait Contexts { self: Analyzer => override final def toString = super.toString + " with " + s"ImportContext { $impInfo; outer.owner = ${outer.owner} }" } - /** A buffer for warnings and errors that are accumulated during speculative type checking. */ + /** A reporter for use during type checking. It has multiple modes for handling errors. + * + * The default (immediate mode) is to send the error to the global reporter. + * When switched into buffering mode via makeBuffering, errors and warnings are buffered and not be reported + * (there's a special case for ambiguity errors for some reason: those are force to the reporter when context.ambiguousErrors, + * or else they are buffered -- TODO: can we simplify this?) + * + * When using the type checker after typers, an error results in a TypeError being thrown. TODO: get rid of this mode. + * + * To handle nested contexts, reporters share buffers. TODO: only buffer in BufferingReporter, emit immediately in ImmediateReporter + */ abstract class ContextReporter(private[this] var _errorBuffer: mutable.LinkedHashSet[AbsTypeError] = null, private[this] var _warningBuffer: mutable.LinkedHashSet[(Position, String)] = null) extends Reporter { type Error = AbsTypeError type Warning = (Position, String) @@ -1254,7 +1255,27 @@ trait Contexts { self: Analyzer => if (context.ambiguousErrors) reporter.error(err.errPos, addDiagString(err.errMsg)) // force reporting... see TODO above else handleSuppressedAmbiguous(err) - def ++=(errors: Traversable[AbsTypeError]): Unit = errorBuffer ++= errors + @inline final def withFreshErrorBuffer[T](expr: => T): T = { + val previousBuffer = _errorBuffer + _errorBuffer = newBuffer + val res = expr // expr will read _errorBuffer + _errorBuffer = previousBuffer + res + } + + @inline final def propagatingErrorsTo[T](target: ContextReporter)(expr: => T): T = { + val res = expr // TODO: make sure we're okay skipping the try/finally overhead + if ((this ne target) && hasErrors) { // `this eq target` in e.g., test/files/neg/divergent-implicit.scala + // assert(target.errorBuffer ne _errorBuffer) + target ++= errors + // TODO: is clearAllErrors necessary? (no tests failed when dropping it) + // NOTE: even though `this ne target`, it may still be that `target.errorBuffer eq _errorBuffer`, + // so don't clear the buffer, but null out the reference so that a new one will be created when necessary (should be never??) + // (we should refactor error buffering to avoid mutation on shared buffers) + clearAllErrors() + } + res + } protected final def info0(pos: Position, msg: String, severity: Severity, force: Boolean): Unit = severity match { @@ -1265,6 +1286,10 @@ trait Contexts { self: Analyzer => final override def hasErrors = super.hasErrors || errorBuffer.nonEmpty + // TODO: everything below should be pushed down to BufferingReporter (related to buffering) + // Implicit relies on this most heavily, but there you know reporter.isInstanceOf[BufferingReporter] + // can we encode this statically? + // have to pass in context because multiple contexts may share the same ReportBuffer def reportFirstDivergentError(fun: Tree, param: Symbol, paramTp: Type)(implicit context: Context): Unit = errors.collectFirst { @@ -1290,13 +1315,28 @@ trait Contexts { self: Analyzer => case _ => false } + def propagateImplicitTypeErrorsTo(target: ContextReporter) = { + errors foreach { + case err@(_: DivergentImplicitTypeError | _: AmbiguousImplicitTypeError) => + target.errorBuffer += err + case _ => + } + // debuglog("propagateImplicitTypeErrorsTo: " + errors) + } + protected def addDiagString(msg: String)(implicit context: Context): String = { val diagUsedDefaultsMsg = "Error occurred in an application involving default arguments." if (context.diagUsedDefaults && !(msg endsWith diagUsedDefaultsMsg)) msg + "\n" + diagUsedDefaultsMsg else msg } - // TODO: deprecate everything below (related to buffering) and push down to BufferingReporter + final def emitWarnings() = if (_warningBuffer != null) { + _warningBuffer foreach { + case (pos, msg) => reporter.warning(pos, msg) + } + _warningBuffer = null + } + // [JZ] Contexts, pre- the SI-7345 refactor, avoided allocating the buffers until needed. This // is replicated here out of conservatism. private def newBuffer[A] = mutable.LinkedHashSet.empty[A] // Important to use LinkedHS for stable results. @@ -1307,9 +1347,13 @@ trait Contexts { self: Analyzer => final def warnings: immutable.Seq[Warning] = warningBuffer.toVector final def firstError: Option[AbsTypeError] = errorBuffer.headOption - final def clearAll(): Unit = { clearAllErrors(); clearAllWarnings() } - final def clearAllErrors(): Unit = errorBuffer.clear() - final def clearAllWarnings(): Unit = warningBuffer.clear() + // TODO: remove ++= and clearAll* entirely in favor of more high-level combinators like withFreshErrorBuffer + final private[typechecker] def ++=(errors: Traversable[AbsTypeError]): Unit = errorBuffer ++= errors + + // null references to buffers instead of clearing them, + // as the buffers may be shared between different reporters + final def clearAll(): Unit = { _errorBuffer = null; _warningBuffer = null } + final def clearAllErrors(): Unit = { _errorBuffer = null } } private[typechecker] class ImmediateReporter(_errorBuffer: mutable.LinkedHashSet[AbsTypeError] = null, _warningBuffer: mutable.LinkedHashSet[(Position, String)] = null) extends ContextReporter(_errorBuffer, _warningBuffer) { diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index e03877dbf99f..d56f4a7ce81b 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -71,13 +71,10 @@ trait Implicits { typingStack.printTyping(tree, "typing implicit: %s %s".format(tree, context.undetparamsString)) val implicitSearchContext = context.makeImplicit(reportAmbiguous) val result = new ImplicitSearch(tree, pt, isView, implicitSearchContext, pos).bestImplicit - if (result.isFailure && saveAmbiguousDivergent && implicitSearchContext.reporter.hasErrors) { - context.reporter ++= (implicitSearchContext.reporter.errors.collect { - case dte: DivergentImplicitTypeError => dte - case ate: AmbiguousImplicitTypeError => ate - }) - debuglog("update buffer: " + implicitSearchContext.reporter.errors) - } + + if (result.isFailure && saveAmbiguousDivergent && implicitSearchContext.reporter.hasErrors) + implicitSearchContext.reporter.propagateImplicitTypeErrorsTo(context.reporter) + // SI-7944 undetermined type parameters that result from inference within typedImplicit land in // `implicitSearchContext.undetparams`, *not* in `context.undetparams` // Here, we copy them up to parent context (analogously to the way the errors are copied above), diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index 535aaffbbf90..fb7651ffd6ee 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -1375,7 +1375,7 @@ trait Infer extends Checkable { // with and without views enabled, and bestForExpectedType will try again // with pt = WildcardType if it fails with pt != WildcardType. val c = context - class InferTwice extends c.TryTwice { + class InferMethodAlternativeTwice extends c.TryTwice { private[this] val OverloadedType(pre, alts) = tree.tpe private[this] var varargsStar = false private[this] val argtpes = argtpes0 mapConserve { @@ -1384,12 +1384,12 @@ trait Infer extends Checkable { } private def followType(sym: Symbol) = followApply(pre memberType sym) + // separate method to help the inliner + private def isAltApplicable(pt: Type)(alt: Symbol) = context inSilentMode { isApplicable(undetparams, followType(alt), argtpes, pt) && !context.reporter.hasErrors } + private def rankAlternatives(sym1: Symbol, sym2: Symbol) = isStrictlyMoreSpecific(followType(sym1), followType(sym2), sym1, sym2) private def bestForExpectedType(pt: Type, isLastTry: Boolean): Unit = { - val applicable0 = alts filter (alt => context inSilentMode isApplicable(undetparams, followType(alt), argtpes, pt)) - val applicable = overloadsToConsiderBySpecificity(applicable0, argtpes, varargsStar) - val ranked = bestAlternatives(applicable)((sym1, sym2) => - isStrictlyMoreSpecific(followType(sym1), followType(sym2), sym1, sym2) - ) + val applicable = overloadsToConsiderBySpecificity(alts filter isAltApplicable(pt), argtpes, varargsStar) + val ranked = bestAlternatives(applicable)(rankAlternatives) ranked match { case best :: competing :: _ => AmbiguousMethodAlternativeError(tree, pre, best, competing, argtpes, pt, isLastTry) // ambiguous case best :: Nil => tree setSymbol best setType (pre memberType best) // success @@ -1405,7 +1405,7 @@ trait Infer extends Checkable { } } - (new InferTwice).apply() + (new InferMethodAlternativeTwice).apply() } /** Assign `tree` the type of all polymorphic alternatives diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index c557af88f23b..8549d3dbbc22 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -464,24 +464,8 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper if (cond) typerWithLocalContext(c)(f) else f(this) @inline - final def typerWithLocalContext[T](c: Context)(f: Typer => T): T = { - val res = f(newTyper(c)) - val errors = c.reporter.errors - if (errors.nonEmpty) { - c.reporter.clearAllErrors() - context.reporter ++= errors - } - res - } - - @inline - final def withSavedContext[T](c: Context)(f: => T) = { - val savedErrors = c.reporter.errors - c.reporter.clearAllErrors() - val res = f - c.reporter ++= savedErrors - res - } + final def typerWithLocalContext[T](c: Context)(f: Typer => T): T = + c.reporter.propagatingErrorsTo(context.reporter)(f(newTyper(c))) /** The typer for a label definition. If this is part of a template we * first have to enter the label definition. @@ -692,19 +676,16 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper SilentTypeError(context1.reporter.errors: _*) } else { // If we have a successful result, emit any warnings it created. - context1.reporter.warnings foreach { - case (pos, msg) => reporter.warning(pos, msg) - } - context1.reporter.clearAllWarnings() + context1.reporter.emitWarnings() SilentResultValue(result) } } else { assert(context.bufferErrors || isPastTyper, "silent mode is not available past typer") - withSavedContext(context){ + + context.reporter.withFreshErrorBuffer { val res = op(this) - val errorsToReport = context.reporter.errors - context.reporter.clearAllErrors() - if (errorsToReport.isEmpty) SilentResultValue(res) else SilentTypeError(errorsToReport.head) + if (!context.reporter.hasErrors) SilentResultValue(res) + else SilentTypeError(context.reporter.firstError.get) } } } catch { From e21096f5ccbb27587bedbf238b18661d158995e1 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Mon, 4 Aug 2014 17:24:45 +0200 Subject: [PATCH 455/826] Separate statistics from functional code; optimize. --- .../tools/nsc/typechecker/Implicits.scala | 77 +++++++++++-------- 1 file changed, 45 insertions(+), 32 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index d56f4a7ce81b..b85c8e6d42c6 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -1342,36 +1342,47 @@ trait Implicits { * If all fails return SearchFailure */ def bestImplicit: SearchResult = { - val failstart = if (Statistics.canEnable) Statistics.startTimer(inscopeFailNanos) else null - val succstart = if (Statistics.canEnable) Statistics.startTimer(inscopeSucceedNanos) else null + val stats = Statistics.canEnable + val failstart = if (stats) Statistics.startTimer(inscopeFailNanos) else null + val succstart = if (stats) Statistics.startTimer(inscopeSucceedNanos) else null var result = searchImplicit(context.implicitss, isLocalToCallsite = true) - if (result.isFailure) { - if (Statistics.canEnable) Statistics.stopTimer(inscopeFailNanos, failstart) - } else { - if (Statistics.canEnable) Statistics.stopTimer(inscopeSucceedNanos, succstart) - if (Statistics.canEnable) Statistics.incCounter(inscopeImplicitHits) + if (stats) { + if (result.isFailure) Statistics.stopTimer(inscopeFailNanos, failstart) + else { + Statistics.stopTimer(inscopeSucceedNanos, succstart) + Statistics.incCounter(inscopeImplicitHits) + } } + if (result.isFailure) { + val failstart = if (stats) Statistics.startTimer(oftypeFailNanos) else null + val succstart = if (stats) Statistics.startTimer(oftypeSucceedNanos) else null + + // SI-6667, never search companions after an ambiguous error in in-scope implicits + val wasAmbigious = result.isAmbiguousFailure + + // TODO: encapsulate val previousErrs = context.reporter.errors context.reporter.clearAllErrors() - val failstart = if (Statistics.canEnable) Statistics.startTimer(oftypeFailNanos) else null - val succstart = if (Statistics.canEnable) Statistics.startTimer(oftypeSucceedNanos) else null - val wasAmbigious = result.isAmbiguousFailure // SI-6667, never search companions after an ambiguous error in in-scope implicits result = materializeImplicit(pt) + // `materializeImplicit` does some preprocessing for `pt` // is it only meant for manifests/tags or we need to do the same for `implicitsOfExpectedType`? if (result.isFailure && !wasAmbigious) result = searchImplicit(implicitsOfExpectedType, isLocalToCallsite = false) - if (result.isFailure) { + if (result.isFailure) context.reporter ++= previousErrs - if (Statistics.canEnable) Statistics.stopTimer(oftypeFailNanos, failstart) - } else { - if (Statistics.canEnable) Statistics.stopTimer(oftypeSucceedNanos, succstart) - if (Statistics.canEnable) Statistics.incCounter(oftypeImplicitHits) + + if (stats) { + if (result.isFailure) Statistics.stopTimer(oftypeFailNanos, failstart) + else { + Statistics.stopTimer(oftypeSucceedNanos, succstart) + Statistics.incCounter(oftypeImplicitHits) + } } } if (result.isSuccess && isView) { @@ -1384,12 +1395,13 @@ trait Implicits { } pt match { case Function1(_, out) => - def prohibit(sym: Symbol) = if (sym.tpe <:< out) { - maybeInvalidConversionError(s"the result type of an implicit conversion must be more specific than ${sym.name}") - result = SearchFailure + // must inline to avoid capturing result + def prohibit(sym: Symbol) = (sym.tpe <:< out) && { + maybeInvalidConversionError(s"the result type of an implicit conversion must be more specific than ${sym.name}") + true } - prohibit(AnyRefClass) - if (settings.isScala211) prohibit(AnyValClass) + if (prohibit(AnyRefClass) || (settings.isScala211 && prohibit(AnyValClass))) + result = SearchFailure case _ => false } if (settings.isScala211 && isInvalidConversionSource(pt)) { @@ -1397,8 +1409,9 @@ trait Implicits { result = SearchFailure } } - if (result.isFailure) - debuglog("no implicits found for "+pt+" "+pt.typeSymbol.info.baseClasses+" "+implicitsOfExpectedType) + + if (result.isFailure && settings.debug) // debuglog is not inlined for some reason + log("no implicits found for "+pt+" "+pt.typeSymbol.info.baseClasses+" "+implicitsOfExpectedType) result } @@ -1420,19 +1433,19 @@ trait Implicits { val eligible = new ImplicitComputation(iss, isLocalToCallsite).eligible eligible.toList.flatMap { (ii: ImplicitInfo) => - // each ImplicitInfo contributes a distinct set of constraints (generated indirectly by typedImplicit) - // thus, start each type var off with a fresh for every typedImplicit - resetTVars() - // any previous errors should not affect us now - context.reporter.clearAllErrors() - val res = typedImplicit(ii, ptChecked = false, isLocalToCallsite) - if (res.tree ne EmptyTree) List((res, tvars map (_.constr))) - else Nil + // each ImplicitInfo contributes a distinct set of constraints (generated indirectly by typedImplicit) + // thus, start each type var off with a fresh for every typedImplicit + resetTVars() + // any previous errors should not affect us now + context.reporter.clearAllErrors() + val res = typedImplicit(ii, ptChecked = false, isLocalToCallsite) + if (res.tree ne EmptyTree) List((res, tvars map (_.constr))) + else Nil + } } - } eligibleInfos(context.implicitss, isLocalToCallsite = true) ++ eligibleInfos(implicitsOfExpectedType, isLocalToCallsite = false) - } + } } object ImplicitNotFoundMsg { From ca9f64dfa20fb8d5a4c022f6b9fd2f18a8ea1028 Mon Sep 17 00:00:00 2001 From: Adriaan Moors Date: Mon, 4 Aug 2014 17:25:45 +0200 Subject: [PATCH 456/826] Encapsulate creating SilentResultValue/SilentTypeError. Do it consistently... --- .../scala/tools/nsc/typechecker/Typers.scala | 22 ++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 8549d3dbbc22..0621fbefe42d 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -658,6 +658,12 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper if (Statistics.canEnable) Statistics.stopCounter(subtypeFailed, subtypeStart) if (Statistics.canEnable) Statistics.stopTimer(failedSilentNanos, failedSilentStart) } + @inline def wrapResult(reporter: ContextReporter, result: T) = + if (reporter.hasErrors) { + stopStats() + SilentTypeError(reporter.errors: _*) + } else SilentResultValue(result) + try { if (context.reportErrors || reportAmbiguousErrors != context.ambiguousErrors || @@ -671,21 +677,17 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper context.undetparams = context1.undetparams context.savedTypeBounds = context1.savedTypeBounds context.namedApplyBlockInfo = context1.namedApplyBlockInfo - if (context1.reporter.hasErrors) { - stopStats() - SilentTypeError(context1.reporter.errors: _*) - } else { - // If we have a successful result, emit any warnings it created. + + // If we have a successful result, emit any warnings it created. + if (!context1.reporter.hasErrors) context1.reporter.emitWarnings() - SilentResultValue(result) - } + + wrapResult(context1.reporter, result) } else { assert(context.bufferErrors || isPastTyper, "silent mode is not available past typer") context.reporter.withFreshErrorBuffer { - val res = op(this) - if (!context.reporter.hasErrors) SilentResultValue(res) - else SilentTypeError(context.reporter.firstError.get) + wrapResult(context.reporter, op(this)) } } } catch { From 1f3319c83721401e31642c1515bd9be7c567abc1 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Wed, 6 Aug 2014 10:02:00 +1000 Subject: [PATCH 457/826] SI-8781 Avoid double-expansion under -Ymacro-expand:discard This mode of macro expansion is used by the presentation compiler to leave the original macro applications ("expandees") in the type checked trees, annotated with the types of the expansions. However, under some circumstances involving implicits, we would re-expand the macro. If the macro wasn't stable, this could lead to a type mismatch. The originally reported problem was with the shapeless `mkSingletonOps` macro. Its expansion had the type of a freshly-named class local to the expansion. Upon the re-expansion, a new class was generated, which lead to errors like: client/Client.scala:4: error: type mismatch; found : fresh$macro$2 required: fresh$macro$1 This commit suppressed re-expansion of the expandee by use of the existing, tree attachment driven mechanism. --- .../scala/tools/nsc/typechecker/Macros.scala | 5 ++++- test/files/pos/t8781/Macro_1.scala | 13 +++++++++++++ test/files/pos/t8781/Test_2.flags | 1 + test/files/pos/t8781/Test_2.scala | 5 +++++ 4 files changed, 23 insertions(+), 1 deletion(-) create mode 100644 test/files/pos/t8781/Macro_1.scala create mode 100644 test/files/pos/t8781/Test_2.flags create mode 100644 test/files/pos/t8781/Test_2.scala diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala index 9c22688581e7..33d3432ae2ca 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala @@ -576,7 +576,10 @@ trait Macros extends MacroRuntimes with Traces with Helpers { // also see http://groups.google.com/group/scala-internals/browse_thread/thread/492560d941b315cc val expanded1 = try onSuccess(duplicateAndKeepPositions(expanded)) finally popMacroContext() if (!hasMacroExpansionAttachment(expanded1)) linkExpandeeAndExpanded(expandee, expanded1) - if (settings.Ymacroexpand.value == settings.MacroExpand.Discard) expandee.setType(expanded1.tpe) + if (settings.Ymacroexpand.value == settings.MacroExpand.Discard) { + suppressMacroExpansion(expandee) + expandee.setType(expanded1.tpe) + } else expanded1 case Fallback(fallback) => onFallback(fallback) case Delayed(delayed) => onDelayed(delayed) diff --git a/test/files/pos/t8781/Macro_1.scala b/test/files/pos/t8781/Macro_1.scala new file mode 100644 index 000000000000..ecd9c5e8d5cf --- /dev/null +++ b/test/files/pos/t8781/Macro_1.scala @@ -0,0 +1,13 @@ +import scala.reflect.macros.whitebox.Context +import language.experimental.macros + +object Macros { + def impl(c: Context) = { + import c.universe._ + val name = TypeName(c.freshName()) + q"class $name extends T; new $name" + } + def fresh: Any = macro impl +} + +trait T diff --git a/test/files/pos/t8781/Test_2.flags b/test/files/pos/t8781/Test_2.flags new file mode 100644 index 000000000000..24e210969040 --- /dev/null +++ b/test/files/pos/t8781/Test_2.flags @@ -0,0 +1 @@ +-Ymacro-expand:discard -Ystop-after:typer diff --git a/test/files/pos/t8781/Test_2.scala b/test/files/pos/t8781/Test_2.scala new file mode 100644 index 000000000000..3ca64065992d --- /dev/null +++ b/test/files/pos/t8781/Test_2.scala @@ -0,0 +1,5 @@ +object Test { + implicit class RichT(t: T) { def augmented = "" } + + Macros.fresh.augmented +} From 72721ff5dd06dea1235ecb71acae0bd61aee4814 Mon Sep 17 00:00:00 2001 From: Dominik Gruntz Date: Wed, 6 Aug 2014 17:12:20 +0200 Subject: [PATCH 458/826] Fixes cut sentences in the generated scaladocs This commit changes all first sentences of library functions which contain `i.e.` or `e.g.` and adds a `,` to prevent that the scaladoc summary sentence is cut after this abbreviation. This is possible as pull/3824 fixed how Scaladoc parses the first sentence of a method description into a sumary sentence(now the first sentence has to end with a dot followed by whitespace). Only docs in the core library are changed (src/library/**/*.scala) and only if they occur in the first sentence. Review by @heathermiller --- src/library/scala/collection/GenMapLike.scala | 2 +- src/library/scala/collection/TraversableOnce.scala | 2 +- src/library/scala/collection/immutable/Stream.scala | 2 +- src/library/scala/collection/immutable/StringLike.scala | 4 ++-- src/library/scala/concurrent/duration/Deadline.scala | 6 +++--- src/library/scala/math/BigDecimal.scala | 6 +++--- src/library/scala/math/BigInt.scala | 6 +++--- src/library/scala/runtime/ScalaRunTime.scala | 2 +- src/library/scala/sys/Prop.scala | 2 +- src/library/scala/util/Properties.scala | 2 +- src/library/scala/util/matching/Regex.scala | 2 +- 11 files changed, 18 insertions(+), 18 deletions(-) diff --git a/src/library/scala/collection/GenMapLike.scala b/src/library/scala/collection/GenMapLike.scala index 4e7d35925106..bce974052247 100644 --- a/src/library/scala/collection/GenMapLike.scala +++ b/src/library/scala/collection/GenMapLike.scala @@ -102,7 +102,7 @@ trait GenMapLike[A, +B, +Repr] extends GenIterableLike[(A, B), Repr] with Equals */ def mapValues[C](f: B => C): GenMap[A, C] - /** Compares two maps structurally; i.e. checks if all mappings + /** Compares two maps structurally; i.e., checks if all mappings * contained in this map are also contained in the other map, * and vice versa. * diff --git a/src/library/scala/collection/TraversableOnce.scala b/src/library/scala/collection/TraversableOnce.scala index a8c4e047ab05..13cd99d91044 100644 --- a/src/library/scala/collection/TraversableOnce.scala +++ b/src/library/scala/collection/TraversableOnce.scala @@ -75,7 +75,7 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] { // at least indirectly. Currently, these are `ArrayOps` and `StringOps`. // It is also implemented in `TraversableOnce[A]`. /** A version of this collection with all - * of the operations implemented sequentially (i.e. in a single-threaded manner). + * of the operations implemented sequentially (i.e., in a single-threaded manner). * * This method returns a reference to this collection. In parallel collections, * it is redefined to return a sequential implementation of this collection. In diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala index d3ff5e8abf42..37a0b373da04 100644 --- a/src/library/scala/collection/immutable/Stream.scala +++ b/src/library/scala/collection/immutable/Stream.scala @@ -469,7 +469,7 @@ self => else super.flatMap(f)(bf) /** Returns all the elements of this `Stream` that satisfy the predicate `p` - * in a new `Stream` - i.e. it is still a lazy data structure. The order of + * in a new `Stream` - i.e., it is still a lazy data structure. The order of * the elements is preserved * * @param p the predicate used to filter the stream. diff --git a/src/library/scala/collection/immutable/StringLike.scala b/src/library/scala/collection/immutable/StringLike.scala index 8e1d950d00fc..738b294ce669 100644 --- a/src/library/scala/collection/immutable/StringLike.scala +++ b/src/library/scala/collection/immutable/StringLike.scala @@ -121,14 +121,14 @@ self => } /** Return all lines in this string in an iterator, excluding trailing line - * end characters, i.e. apply `.stripLineEnd` to all lines + * end characters, i.e., apply `.stripLineEnd` to all lines * returned by `linesWithSeparators`. */ def lines: Iterator[String] = linesWithSeparators map (line => new WrappedString(line).stripLineEnd) /** Return all lines in this string in an iterator, excluding trailing line - * end characters, i.e. apply `.stripLineEnd` to all lines + * end characters, i.e., apply `.stripLineEnd` to all lines * returned by `linesWithSeparators`. */ @deprecated("Use `lines` instead.","2.11.0") diff --git a/src/library/scala/concurrent/duration/Deadline.scala b/src/library/scala/concurrent/duration/Deadline.scala index 61cbe4753072..a25a4786027f 100644 --- a/src/library/scala/concurrent/duration/Deadline.scala +++ b/src/library/scala/concurrent/duration/Deadline.scala @@ -25,15 +25,15 @@ package scala.concurrent.duration */ case class Deadline private (time: FiniteDuration) extends Ordered[Deadline] { /** - * Return a deadline advanced (i.e. moved into the future) by the given duration. + * Return a deadline advanced (i.e., moved into the future) by the given duration. */ def +(other: FiniteDuration): Deadline = copy(time = time + other) /** - * Return a deadline moved backwards (i.e. towards the past) by the given duration. + * Return a deadline moved backwards (i.e., towards the past) by the given duration. */ def -(other: FiniteDuration): Deadline = copy(time = time - other) /** - * Calculate time difference between this and the other deadline, where the result is directed (i.e. may be negative). + * Calculate time difference between this and the other deadline, where the result is directed (i.e., may be negative). */ def -(other: Deadline): FiniteDuration = time - other.time /** diff --git a/src/library/scala/math/BigDecimal.scala b/src/library/scala/math/BigDecimal.scala index bcbed645a750..5a81710986b5 100644 --- a/src/library/scala/math/BigDecimal.scala +++ b/src/library/scala/math/BigDecimal.scala @@ -617,10 +617,10 @@ extends ScalaNumber with ScalaNumericConversions with Serializable { */ def abs: BigDecimal = if (signum < 0) unary_- else this - /** Returns the sign of this BigDecimal, i.e. + /** Returns the sign of this BigDecimal; * -1 if it is less than 0, - * +1 if it is greater than 0 - * 0 if it is equal to 0 + * +1 if it is greater than 0, + * 0 if it is equal to 0. */ def signum: Int = this.bigDecimal.signum() diff --git a/src/library/scala/math/BigInt.scala b/src/library/scala/math/BigInt.scala index 689fc0c3e1a5..abc7371d9fb0 100644 --- a/src/library/scala/math/BigInt.scala +++ b/src/library/scala/math/BigInt.scala @@ -282,10 +282,10 @@ final class BigInt(val bigInteger: BigInteger) extends ScalaNumber with ScalaNum */ def abs: BigInt = new BigInt(this.bigInteger.abs()) - /** Returns the sign of this BigInt, i.e. + /** Returns the sign of this BigInt; * -1 if it is less than 0, - * +1 if it is greater than 0 - * 0 if it is equal to 0 + * +1 if it is greater than 0, + * 0 if it is equal to 0. */ def signum: Int = this.bigInteger.signum() diff --git a/src/library/scala/runtime/ScalaRunTime.scala b/src/library/scala/runtime/ScalaRunTime.scala index 5fb24f2a366a..f50059ce5488 100644 --- a/src/library/scala/runtime/ScalaRunTime.scala +++ b/src/library/scala/runtime/ScalaRunTime.scala @@ -62,7 +62,7 @@ object ScalaRunTime { } /** Return the class object representing an unboxed value type, - * e.g. classOf[int], not classOf[java.lang.Integer]. The compiler + * e.g., classOf[int], not classOf[java.lang.Integer]. The compiler * rewrites expressions like 5.getClass to come here. */ def anyValClass[T <: AnyVal : ClassTag](value: T): jClass[T] = diff --git a/src/library/scala/sys/Prop.scala b/src/library/scala/sys/Prop.scala index 04c7b5108c16..17ae8cb69ca1 100644 --- a/src/library/scala/sys/Prop.scala +++ b/src/library/scala/sys/Prop.scala @@ -20,7 +20,7 @@ package sys * @since 2.9 */ trait Prop[+T] { - /** The full name of the property, e.g. "java.awt.headless". + /** The full name of the property, e.g., "java.awt.headless". */ def key: String diff --git a/src/library/scala/util/Properties.scala b/src/library/scala/util/Properties.scala index 2daa4de9a6df..8835730d9571 100644 --- a/src/library/scala/util/Properties.scala +++ b/src/library/scala/util/Properties.scala @@ -107,7 +107,7 @@ private[scala] trait PropertiesTrait { val versionString = "version " + scalaPropOrElse("version.number", "(unknown)") val copyrightString = scalaPropOrElse("copyright.string", "Copyright 2002-2013, LAMP/EPFL") - /** This is the encoding to use reading in source files, overridden with -encoding + /** This is the encoding to use reading in source files, overridden with -encoding. * Note that it uses "prop" i.e. looks in the scala jar, not the system properties. */ def sourceEncoding = scalaPropOrElse("file.encoding", "UTF-8") diff --git a/src/library/scala/util/matching/Regex.scala b/src/library/scala/util/matching/Regex.scala index f35ea566bab0..2e1bfb02e4b3 100644 --- a/src/library/scala/util/matching/Regex.scala +++ b/src/library/scala/util/matching/Regex.scala @@ -543,7 +543,7 @@ object Regex { if (start(i) >= 0) source.subSequence(start(i), end(i)).toString else null - /** All matched subgroups, i.e. not including group(0) */ + /** All matched subgroups, i.e., not including group(0) */ def subgroups: List[String] = (1 to groupCount).toList map group /** The char sequence before first character of match, From 70c3360d6f49f28216f28b7e25f61142481db9e6 Mon Sep 17 00:00:00 2001 From: rubyu Date: Thu, 7 Aug 2014 15:39:25 +0900 Subject: [PATCH 459/826] SI-7350 Prevent resource leaks in PipedProcesses.runAndExitValue() --- src/library/scala/sys/process/BasicIO.scala | 2 +- .../scala/sys/process/ProcessImpl.scala | 134 ++++---- src/library/scala/sys/process/package.scala | 30 +- test/files/run/t7350.check | 43 +++ test/files/run/t7350.scala | 302 ++++++++++++++++++ 5 files changed, 438 insertions(+), 73 deletions(-) create mode 100644 test/files/run/t7350.check create mode 100644 test/files/run/t7350.scala diff --git a/src/library/scala/sys/process/BasicIO.scala b/src/library/scala/sys/process/BasicIO.scala index b31bbf05407b..866dac4458c8 100644 --- a/src/library/scala/sys/process/BasicIO.scala +++ b/src/library/scala/sys/process/BasicIO.scala @@ -221,7 +221,7 @@ object BasicIO { */ def transferFully(in: InputStream, out: OutputStream): Unit = try transferFullyImpl(in, out) - catch onInterrupt(()) + catch onIOInterrupt(()) private[this] def appendLine(buffer: Appendable): String => Unit = line => { buffer append line diff --git a/src/library/scala/sys/process/ProcessImpl.scala b/src/library/scala/sys/process/ProcessImpl.scala index 2b7fcdeb73b6..d15f1a2b3d78 100644 --- a/src/library/scala/sys/process/ProcessImpl.scala +++ b/src/library/scala/sys/process/ProcessImpl.scala @@ -109,45 +109,46 @@ private[process] trait ProcessImpl { } private[process] class PipedProcesses(a: ProcessBuilder, b: ProcessBuilder, defaultIO: ProcessIO, toError: Boolean) extends CompoundProcess { - protected[this] override def runAndExitValue() = { - val currentSource = new SyncVar[Option[InputStream]] - val pipeOut = new PipedOutputStream - val source = new PipeSource(currentSource, pipeOut, a.toString) + protected[this] override def runAndExitValue() = runAndExitValue(new PipeSource(a.toString), new PipeSink(b.toString)) + protected[this] def runAndExitValue(source: PipeSource, sink: PipeSink): Option[Int] = { + source connectOut sink source.start() - - val pipeIn = new PipedInputStream(pipeOut) - val currentSink = new SyncVar[Option[OutputStream]] - val sink = new PipeSink(pipeIn, currentSink, b.toString) sink.start() - def handleOutOrError(fromOutput: InputStream) = currentSource put Some(fromOutput) + /** Release PipeSource, PipeSink and Process in the correct order. + * If once connect Process with Source or Sink, then the order of releasing them + * must be Source -> Sink -> Process, otherwise IOException will be thrown. */ + def releaseResources(so: PipeSource, sk: PipeSink, p: Process *) = { + so.release() + sk.release() + p foreach( _.destroy() ) + } val firstIO = - if (toError) - defaultIO.withError(handleOutOrError) - else - defaultIO.withOutput(handleOutOrError) - val secondIO = defaultIO.withInput(toInput => currentSink put Some(toInput)) - - val second = b.run(secondIO) - val first = a.run(firstIO) - try { - runInterruptible { - val exit1 = first.exitValue() - currentSource put None - currentSink put None - val exit2 = second.exitValue() - // Since file redirection (e.g. #>) is implemented as a piped process, - // we ignore its exit value so cmd #> file doesn't always return 0. - if (b.hasExitValue) exit2 else exit1 - } { - first.destroy() - second.destroy() + if (toError) defaultIO.withError(source.connectIn) + else defaultIO.withOutput(source.connectIn) + val secondIO = defaultIO.withInput(sink.connectOut) + + val second = + try b.run(secondIO) + catch onError { err => + releaseResources(source, sink) + throw err } - } - finally { - BasicIO close pipeIn - BasicIO close pipeOut + val first = + try a.run(firstIO) + catch onError { err => + releaseResources(source, sink, second) + throw err + } + runInterruptible { + val exit1 = first.exitValue() + val exit2 = second.exitValue() + // Since file redirection (e.g. #>) is implemented as a piped process, + // we ignore its exit value so cmd #> file doesn't always return 0. + if (b.hasExitValue) exit2 else exit1 + } { + releaseResources(source, sink, first, second) } } } @@ -168,37 +169,46 @@ private[process] trait ProcessImpl { } } - private[process] class PipeSource( - currentSource: SyncVar[Option[InputStream]], - pipe: PipedOutputStream, - label: => String - ) extends PipeThread(false, () => label) { - - final override def run(): Unit = currentSource.get match { - case Some(source) => - try runloop(source, pipe) - finally currentSource.unset() - - run() - case None => - currentSource.unset() - BasicIO close pipe + private[process] class PipeSource(label: => String) extends PipeThread(false, () => label) { + protected[this] val pipe = new PipedOutputStream + protected[this] val source = new LinkedBlockingQueue[Option[InputStream]] + override def run(): Unit = { + try { + source.take match { + case Some(in) => runloop(in, pipe) + case None => + } + } + catch onInterrupt(()) + finally BasicIO close pipe + } + def connectIn(in: InputStream): Unit = source add Some(in) + def connectOut(sink: PipeSink): Unit = sink connectIn pipe + def release(): Unit = { + interrupt() + source add None + join() } } - private[process] class PipeSink( - pipe: PipedInputStream, - currentSink: SyncVar[Option[OutputStream]], - label: => String - ) extends PipeThread(true, () => label) { - - final override def run(): Unit = currentSink.get match { - case Some(sink) => - try runloop(pipe, sink) - finally currentSink.unset() - - run() - case None => - currentSink.unset() + private[process] class PipeSink(label: => String) extends PipeThread(true, () => label) { + protected[this] val pipe = new PipedInputStream + protected[this] val sink = new LinkedBlockingQueue[Option[OutputStream]] + override def run(): Unit = { + try { + sink.take match { + case Some(out) => runloop(pipe, out) + case None => + } + } + catch onInterrupt(()) + finally BasicIO close pipe + } + def connectOut(out: OutputStream): Unit = sink add Some(out) + def connectIn(pipeOut: PipedOutputStream): Unit = pipe connect pipeOut + def release(): Unit = { + interrupt() + sink add None + join() } } diff --git a/src/library/scala/sys/process/package.scala b/src/library/scala/sys/process/package.scala index 1340a6c415cb..91fa99e3df66 100644 --- a/src/library/scala/sys/process/package.scala +++ b/src/library/scala/sys/process/package.scala @@ -224,16 +224,26 @@ package scala.sys { final val processDebug = props contains "scala.process.debug" dbg("Initializing process package.") - type =?>[-A, +B] = PartialFunction[A, B] - type Closeable = java.io.Closeable - type File = java.io.File - type IOException = java.io.IOException - type InputStream = java.io.InputStream - type JProcess = java.lang.Process - type JProcessBuilder = java.lang.ProcessBuilder - type OutputStream = java.io.OutputStream - type SyncVar[T] = scala.concurrent.SyncVar[T] - type URL = java.net.URL + type =?>[-A, +B] = PartialFunction[A, B] + type Closeable = java.io.Closeable + type File = java.io.File + type IOException = java.io.IOException + type InterruptedIOException = java.io.InterruptedIOException + type InputStream = java.io.InputStream + type JProcess = java.lang.Process + type JProcessBuilder = java.lang.ProcessBuilder + type LinkedBlockingQueue[T] = java.util.concurrent.LinkedBlockingQueue[T] + type OutputStream = java.io.OutputStream + type SyncVar[T] = scala.concurrent.SyncVar[T] + type URL = java.net.URL + + def onError[T](handler: Throwable => T): Throwable =?> T = { + case e @ _ => handler(e) + } + + def onIOInterrupt[T](handler: => T): Throwable =?> T = { + case _: InterruptedIOException => handler + } def onInterrupt[T](handler: => T): Throwable =?> T = { case _: InterruptedException => handler diff --git a/test/files/run/t7350.check b/test/files/run/t7350.check new file mode 100644 index 000000000000..5959e0440083 --- /dev/null +++ b/test/files/run/t7350.check @@ -0,0 +1,43 @@ +PipedProcesses need not to release resources when it normally ends +- source.releaseCount: 0 +- sink.releaseCount: 0 +- a.destroyCount: 0 +- b.destroyCount: 0 +PipedProcesses must release resources when b.run() fails +- source.releaseCount: 1 +- sink.releaseCount: 1 +- a.destroyCount: 0 +- b.destroyCount: 0 +PipedProcesses must release resources when a.run() fails +- source.releaseCount: 1 +- sink.releaseCount: 1 +- a.destroyCount: 0 +- b.destroyCount: 1 +PipedProcesses must release resources when interrupted waiting for first.exitValue() +- source.releaseCount: 1 +- sink.releaseCount: 1 +- a.destroyCount: 1 +- b.destroyCount: 1 +PipedProcesses must release resources when interrupted waiting for second.exitValue() +- source.releaseCount: 1 +- sink.releaseCount: 1 +- a.destroyCount: 1 +- b.destroyCount: 1 +PipeSource and PipeSink must release resources when it normally ends +- in.closed: true +- out.closed: true +- source.isReleased: true +- sink.isReleased: true +PipeSource and PipeSink must release resources when when waiting for source.take() +- out.closed: true +- source.isReleased: true +- sink.isReleased: true +PipeSource and PipeSink must release resources when when waiting for sink.take() +- in.closed: true +- source.isReleased: true +- sink.isReleased: true +PipeSource and PipeSink must release resources when copying stream +- in.closed: true +- out.closed: true +- source.isReleased: true +- sink.isReleased: true diff --git a/test/files/run/t7350.scala b/test/files/run/t7350.scala new file mode 100644 index 000000000000..156d2f0719cf --- /dev/null +++ b/test/files/run/t7350.scala @@ -0,0 +1,302 @@ + +import scala.sys.process.debug._ +import scala.sys.process.{ProcessLogger, BasicIO} +import java.io.{Closeable, ByteArrayInputStream, ByteArrayOutputStream, InputStream, IOException} +import scala.concurrent.{Future, Await} +import scala.concurrent.duration.{Duration, SECONDS} +import scala.util.control.Exception._ +import scala.concurrent.ExecutionContext.Implicits.global + +object Test extends App { + // Each test normally ends in a moment, but for a worst case, + // waits until 5 seconds and breaks off. + + // Tests for PipedProcesses + + println("PipedProcesses need not to release resources when it normally ends") + + { + val io = BasicIO(false, ProcessLogger(_ => ())) + val source = new PipeSourceMock + val sink = new PipeSinkMock + val a = new ProcessMock(error = false) + val b = new ProcessMock(error = false) + val p = new PipedProcesses(new ProcessBuilderMock(a, error = false), new ProcessBuilderMock(b, error = false), io, false) + val f = Future { + p.callRunAndExitValue(source, sink) + } + Await.result(f, Duration(5, SECONDS)) + println(s"- source.releaseCount: ${source.releaseCount}") + println(s"- sink.releaseCount: ${sink.releaseCount}") + println(s"- a.destroyCount: ${a.destroyCount}") + println(s"- b.destroyCount: ${b.destroyCount}") + } + + println("PipedProcesses must release resources when b.run() fails") + + { + val io = BasicIO(false, ProcessLogger(_ => ())) + val source = new PipeSourceMock + val sink = new PipeSinkMock + val a = new ProcessMock(error = false) + val b = new ProcessMock(error = false) + val p = new PipedProcesses(new ProcessBuilderMock(a, error = false), new ProcessBuilderMock(b, error = true), io, false) + val f = Future { + ignoring(classOf[IOException]) { + p.callRunAndExitValue(source, sink) + } + } + Await.result(f, Duration(5, SECONDS)) + println(s"- source.releaseCount: ${source.releaseCount}") + println(s"- sink.releaseCount: ${sink.releaseCount}") + println(s"- a.destroyCount: ${a.destroyCount}") + println(s"- b.destroyCount: ${b.destroyCount}") + } + + println("PipedProcesses must release resources when a.run() fails") + + { + val io = BasicIO(false, ProcessLogger(_ => ())) + val source = new PipeSourceMock + val sink = new PipeSinkMock + val a = new ProcessMock(error = false) + val b = new ProcessMock(error = false) + val p = new PipedProcesses(new ProcessBuilderMock(a, error = true), new ProcessBuilderMock(b, error = false), io, false) + val f = Future { + ignoring(classOf[IOException]) { + p.callRunAndExitValue(source, sink) + } + } + Await.result(f, Duration(5, SECONDS)) + println(s"- source.releaseCount: ${source.releaseCount}") + println(s"- sink.releaseCount: ${sink.releaseCount}") + println(s"- a.destroyCount: ${a.destroyCount}") + println(s"- b.destroyCount: ${b.destroyCount}") + } + + println("PipedProcesses must release resources when interrupted waiting for first.exitValue()") + + { + val io = BasicIO(false, ProcessLogger(_ => ())) + val source = new PipeSourceMock + val sink = new PipeSinkMock + val a = new ProcessMock(error = true) + val b = new ProcessMock(error = false) + val p = new PipedProcesses(new ProcessBuilderMock(a, error = false), new ProcessBuilderMock(b, error = false), io, false) + val f = Future { + p.callRunAndExitValue(source, sink) + } + Await.result(f, Duration(5, SECONDS)) + println(s"- source.releaseCount: ${source.releaseCount}") + println(s"- sink.releaseCount: ${sink.releaseCount}") + println(s"- a.destroyCount: ${a.destroyCount}") + println(s"- b.destroyCount: ${b.destroyCount}") + } + + println("PipedProcesses must release resources when interrupted waiting for second.exitValue()") + + { + val io = BasicIO(false, ProcessLogger(_ => ())) + val source = new PipeSourceMock + val sink = new PipeSinkMock + val a = new ProcessMock(error = false) + val b = new ProcessMock(error = true) + val p = new PipedProcesses(new ProcessBuilderMock(a, error = false), new ProcessBuilderMock(b, error = false), io, false) + val f = Future { + p.callRunAndExitValue(source, sink) + } + Await.result(f, Duration(5, SECONDS)) + println(s"- source.releaseCount: ${source.releaseCount}") + println(s"- sink.releaseCount: ${sink.releaseCount}") + println(s"- a.destroyCount: ${a.destroyCount}") + println(s"- b.destroyCount: ${b.destroyCount}") + } + + // Tests for PipeSource and PipeSink + + trait CloseChecking extends Closeable { + var closed = false + override def close() = closed = true + } + class DebugOutputStream extends ByteArrayOutputStream with CloseChecking + class DebugInputStream(s: String) extends ByteArrayInputStream(s.getBytes()) with CloseChecking + class DebugInfinityInputStream extends InputStream with CloseChecking { + def read() = 1 + } + + def sourceSink() = { + val source = new PipeSource + val sink = new PipeSink + source connectOut sink + source.start() + sink.start() + (source, sink) + } + + println("PipeSource and PipeSink must release resources when it normally ends") + + { + val in = new DebugInputStream("aaa") + val (source, sink) = sourceSink() + val out = new DebugOutputStream + source connectIn in + sink connectOut out + val f = Future { + source.join() + sink.join() + } + Await.result(f, Duration(5, SECONDS)) + println(s"- in.closed: ${in.closed}") + println(s"- out.closed: ${out.closed}") + println(s"- source.isReleased: ${source.isReleased}") + println(s"- sink.isReleased: ${sink.isReleased}") + } + + println("PipeSource and PipeSink must release resources when when waiting for source.take()") + + { + val (source, sink) = sourceSink() + val out = new DebugOutputStream + sink connectOut out + val f = Future { + sink.ensureRunloopStarted() + source.release() + sink.release() + } + Await.result(f, Duration(5, SECONDS)) + println(s"- out.closed: ${out.closed}") + println(s"- source.isReleased: ${source.isReleased}") + println(s"- sink.isReleased: ${sink.isReleased}") + } + + println("PipeSource and PipeSink must release resources when when waiting for sink.take()") + + { + val in = new DebugInputStream("aaa") + val (source, sink) = sourceSink() + source connectIn in + val f = Future { + source.ensureRunloopStarted() + source.release() + sink.release() + } + Await.result(f, Duration(5, SECONDS)) + println(s"- in.closed: ${in.closed}") + println(s"- source.isReleased: ${source.isReleased}") + println(s"- sink.isReleased: ${sink.isReleased}") + } + + println("PipeSource and PipeSink must release resources when copying stream") + + { + val in = new DebugInfinityInputStream + val (source, sink) = sourceSink() + val out = new DebugOutputStream + source connectIn in + sink connectOut out + val f = Future { + source.ensureRunloopStarted() + sink.ensureRunloopStarted() + source.release() + sink.release() + } + Await.result(f, Duration(5, SECONDS)) + println(s"- in.closed: ${in.closed}") + println(s"- out.closed: ${out.closed}") + println(s"- source.isReleased: ${source.isReleased}") + println(s"- sink.isReleased: ${sink.isReleased}") + } +} + +package scala.sys.process { + import java.io._ + import java.lang.reflect.InvocationTargetException + + object debug { + + class ProcessMock(error: Boolean) extends Process { + var destroyCount = 0 + def exitValue(): Int = { + if (error) { + throw new InterruptedException() + } + 0 + } + def destroy(): Unit = { destroyCount += 1 } + } + + class ProcessBuilderMock(process: Process, error: Boolean) extends ProcessBuilder.AbstractBuilder { + override def run(io: ProcessIO): Process = { + if (error) { + throw new IOException() + } + process + } + } + + class PipeSinkMock extends Process.PipeSink("PipeSinkMock") { + var releaseCount = 0 + override val pipe = null + override val sink = null + override def run(): Unit = {} + override def connectOut(out: OutputStream): Unit = {} + override def connectIn(pipeOut: PipedOutputStream): Unit = {} + override def release(): Unit = { releaseCount += 1 } + } + + class PipeSourceMock extends Process.PipeSource("PipeSourceMock") { + var releaseCount = 0 + override val pipe = null + override val source = null + override def run(): Unit = {} + override def connectIn(in: InputStream): Unit = {} + override def connectOut(sink: Process.PipeSink): Unit = {} + override def release(): Unit = { releaseCount += 1 } + } + + class PipedProcesses(a: ProcessBuilder, b: ProcessBuilder, defaultIO: ProcessIO, toError: Boolean) + extends Process.PipedProcesses(a, b, defaultIO, toError) { + def callRunAndExitValue(source: Process.PipeSource, sink: Process.PipeSink) = { + val m = classOf[Process.PipedProcesses].getDeclaredMethod("runAndExitValue", classOf[Process.PipeSource], classOf[Process.PipeSink]) + m.setAccessible(true) + try m.invoke(this, source, sink).asInstanceOf[Option[Int]] + catch { + case err: InvocationTargetException => throw err.getTargetException + } + } + } + + def throwsIOException(f: => Unit) = { + try { f; false } + catch { case _: IOException => true } + } + + class PipeSink extends Process.PipeSink("TestPipeSink") { + def ensureRunloopStarted() = { + while (sink.size() > 0) { + Thread.sleep(1) + } + } + def isReleased = { + val field = classOf[Process.PipeSink].getDeclaredField("pipe") + field.setAccessible(true) + val pipe = field.get(this).asInstanceOf[PipedInputStream] + !this.isAlive && throwsIOException { pipe.read() } + } + } + + class PipeSource extends Process.PipeSource("TestPipeSource") { + def ensureRunloopStarted() = { + while (source.size() > 0) { + Thread.sleep(1) + } + } + def isReleased = { + val field = classOf[Process.PipeSource].getDeclaredField("pipe") + field.setAccessible(true) + val pipe = field.get(this).asInstanceOf[PipedOutputStream] + !this.isAlive && throwsIOException { pipe.write(1) } + } + } + } +} \ No newline at end of file From 9e13f7ef496051937b79ecd1db7412b29e6f6c4f Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Thu, 7 Aug 2014 17:23:15 +0200 Subject: [PATCH 460/826] remove jline sources from src/ now that we use a released jline. We don't need those, right? We don't even build that folder anymore (since 1b0fa91), it is just dead code. --- src/jline/LICENSE.txt | 33 - src/jline/README.md | 24 - src/jline/build.sbt | 49 - src/jline/manual-test.sh | 9 - src/jline/project/build.properties | 1 - src/jline/project/plugins.sbt | 3 - .../tools/jline/AnsiWindowsTerminal.java | 90 - .../tools/jline/NoInterruptUnixTerminal.java | 44 - .../main/java/scala/tools/jline/Terminal.java | 59 - .../scala/tools/jline/TerminalFactory.java | 173 -- .../scala/tools/jline/TerminalSupport.java | 179 -- .../java/scala/tools/jline/UnixTerminal.java | 248 -- .../tools/jline/UnsupportedTerminal.java | 25 - .../scala/tools/jline/WindowsTerminal.java | 468 ---- .../tools/jline/console/ConsoleReader.java | 2185 ----------------- .../tools/jline/console/CursorBuffer.java | 106 - .../java/scala/tools/jline/console/Key.java | 82 - .../scala/tools/jline/console/Operation.java | 291 --- .../console/completer/AggregateCompleter.java | 108 - .../console/completer/ArgumentCompleter.java | 398 --- .../CandidateListCompletionHandler.java | 193 -- .../jline/console/completer/Completer.java | 37 - .../console/completer/CompletionHandler.java | 25 - .../console/completer/EnumCompleter.java | 35 - .../console/completer/FileNameCompleter.java | 133 - .../console/completer/NullCompleter.java | 39 - .../console/completer/StringsCompleter.java | 79 - .../jline/console/completer/package-info.java | 22 - .../jline/console/history/FileHistory.java | 106 - .../tools/jline/console/history/History.java | 71 - .../jline/console/history/MemoryHistory.java | 318 --- .../console/history/PersistentHistory.java | 34 - .../jline/console/history/package-info.java | 22 - .../tools/jline/console/package-info.java | 22 - .../tools/jline/internal/Configuration.java | 127 - .../java/scala/tools/jline/internal/Log.java | 112 - .../ReplayPrefixOneCharInputStream.java | 95 - .../jline/internal/TerminalLineSettings.java | 217 -- .../tools/jline/internal/package-info.java | 22 - .../java/scala/tools/jline/package-info.java | 22 - .../CandidateListCompletionHandler.properties | 4 - .../scala/tools/jline/keybindings.properties | 71 - .../tools/jline/windowsbindings.properties | 71 - .../tools/jline/TerminalFactoryTest.java | 34 - .../jline/console/ConsoleReaderTest.java | 261 -- .../console/ConsoleReaderTestSupport.java | 143 -- .../tools/jline/console/EditLineTest.java | 208 -- .../completer/ArgumentCompleterTest.java | 46 - .../console/completer/NullCompleterTest.java | 39 - .../completer/StringsCompleterTest.java | 40 - .../jline/console/history/HistoryTest.java | 79 - .../console/history/MemoryHistoryTest.java | 99 - .../scala/tools/jline/example/Example.java | 107 - .../internal/TerminalLineSettingsTest.java | 146 -- 54 files changed, 7654 deletions(-) delete mode 100644 src/jline/LICENSE.txt delete mode 100644 src/jline/README.md delete mode 100644 src/jline/build.sbt delete mode 100755 src/jline/manual-test.sh delete mode 100644 src/jline/project/build.properties delete mode 100644 src/jline/project/plugins.sbt delete mode 100644 src/jline/src/main/java/scala/tools/jline/AnsiWindowsTerminal.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/NoInterruptUnixTerminal.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/Terminal.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/TerminalFactory.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/TerminalSupport.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/UnixTerminal.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/UnsupportedTerminal.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/WindowsTerminal.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/ConsoleReader.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/CursorBuffer.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/Key.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/Operation.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/completer/AggregateCompleter.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/completer/ArgumentCompleter.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/completer/CandidateListCompletionHandler.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/completer/Completer.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/completer/CompletionHandler.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/completer/EnumCompleter.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/completer/FileNameCompleter.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/completer/NullCompleter.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/completer/StringsCompleter.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/completer/package-info.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/history/FileHistory.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/history/History.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/history/MemoryHistory.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/history/PersistentHistory.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/history/package-info.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/console/package-info.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/internal/Configuration.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/internal/Log.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/internal/ReplayPrefixOneCharInputStream.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/internal/TerminalLineSettings.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/internal/package-info.java delete mode 100644 src/jline/src/main/java/scala/tools/jline/package-info.java delete mode 100644 src/jline/src/main/resources/scala/tools/jline/console/completer/CandidateListCompletionHandler.properties delete mode 100644 src/jline/src/main/resources/scala/tools/jline/keybindings.properties delete mode 100644 src/jline/src/main/resources/scala/tools/jline/windowsbindings.properties delete mode 100644 src/jline/src/test/java/scala/tools/jline/TerminalFactoryTest.java delete mode 100644 src/jline/src/test/java/scala/tools/jline/console/ConsoleReaderTest.java delete mode 100644 src/jline/src/test/java/scala/tools/jline/console/ConsoleReaderTestSupport.java delete mode 100644 src/jline/src/test/java/scala/tools/jline/console/EditLineTest.java delete mode 100644 src/jline/src/test/java/scala/tools/jline/console/completer/ArgumentCompleterTest.java delete mode 100644 src/jline/src/test/java/scala/tools/jline/console/completer/NullCompleterTest.java delete mode 100644 src/jline/src/test/java/scala/tools/jline/console/completer/StringsCompleterTest.java delete mode 100644 src/jline/src/test/java/scala/tools/jline/console/history/HistoryTest.java delete mode 100644 src/jline/src/test/java/scala/tools/jline/console/history/MemoryHistoryTest.java delete mode 100644 src/jline/src/test/java/scala/tools/jline/example/Example.java delete mode 100644 src/jline/src/test/java/scala/tools/jline/internal/TerminalLineSettingsTest.java diff --git a/src/jline/LICENSE.txt b/src/jline/LICENSE.txt deleted file mode 100644 index 1cdc44c211bd..000000000000 --- a/src/jline/LICENSE.txt +++ /dev/null @@ -1,33 +0,0 @@ -Copyright (c) 2002-2006, Marc Prud'hommeaux -All rights reserved. - -Redistribution and use in source and binary forms, with or -without modification, are permitted provided that the following -conditions are met: - -Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - -Redistributions in binary form must reproduce the above copyright -notice, this list of conditions and the following disclaimer -in the documentation and/or other materials provided with -the distribution. - -Neither the name of JLine nor the names of its contributors -may be used to endorse or promote products derived from this -software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, -BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY -AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO -EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, -OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, -PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED -AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING -IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED -OF THE POSSIBILITY OF SUCH DAMAGE. - diff --git a/src/jline/README.md b/src/jline/README.md deleted file mode 100644 index 829476145d4e..000000000000 --- a/src/jline/README.md +++ /dev/null @@ -1,24 +0,0 @@ -Description ------------ - -JLine 2.x - -License -------- - -BSD - -Building --------- - -### Requirements - -* SBT -* Java 5+ - -This is a fork with scala specific modifications. -The original repository was: git://github.com/jdillon/jline2.git - -You can now build with sbt: - - sbt update proguard diff --git a/src/jline/build.sbt b/src/jline/build.sbt deleted file mode 100644 index 873f7574f129..000000000000 --- a/src/jline/build.sbt +++ /dev/null @@ -1,49 +0,0 @@ -seq(ProguardPlugin.proguardSettings :_*) - -name := "jline" - -organization := "org.scala-lang" - -version := "2.11.0-SNAPSHOT" - -scalaVersion := "2.10.1" - -// Only need these because of weird testing jline issues. -retrieveManaged := true - -parallelExecution in Test := false - -libraryDependencies ++= Seq( - "org.fusesource.jansi" % "jansi" % "1.10", - "com.novocode" % "junit-interface" % "0.9" % "test->default" -) - -javacOptions ++= Seq("-source", "1.5", "-target", "1.5") - -proguardOptions ++= Seq( - "-dontshrink", - "-keep class *", - "-keepdirectories" -) - -proguardInJars := Nil - -makeInJarFilter ~= { prevFilter => - val jansiFilter = List( - "!META-INF/MANIFEST.MF", - "org/fusesource/hawtjni/runtime", - "org/fusesource/hawtjni/runtime/Callback.class", - "org/fusesource/hawtjni/runtime/Library.class", - "!org/fusesource/hawtjni/**", - "!META-INF/maven/org.fusesource.hawtjni", - "!META-INF/maven/org.fusesource.jansi", - "!META-INF/maven/org.fusesource.hawtjni/**", - "!META-INF/maven/org.fusesource.jansi/**" - ).mkString(",") - // In sbt 0.9.8 the scala-library.jar line was not necessary, - // but in 0.9.9 it started showing up here. Who knows. - file => - if (file startsWith "jansi-") jansiFilter - else if (file == "scala-library.jar") "!**" - else prevFilter(file) -} diff --git a/src/jline/manual-test.sh b/src/jline/manual-test.sh deleted file mode 100755 index 744e1756e8aa..000000000000 --- a/src/jline/manual-test.sh +++ /dev/null @@ -1,9 +0,0 @@ -#!/usr/bin/env bash -# -# Apparently the jline bundled with sbt interferes with testing some -# changes: for instance after changing the keybindings I kept seeing -# failures until I realized what was happening and bypassed sbt, like this. -CP=lib_managed/jars/com.novocode/junit-interface/junit-interface-0.9.jar:lib_managed/jars/junit/junit-dep/junit-dep-4.8.2.jar:lib_managed/jars/org.fusesource.jansi/jansi/jansi-1.10.jar:lib_managed/jars/org.hamcrest/hamcrest-core/hamcrest-core-1.1.jar:lib_managed/jars/org.scala-tools.testing/test-interface/test-interface-0.5.jar:target/scala-2.10/test-classes:target/scala-2.10/jline_2.10-2.11.0-SNAPSHOT.min.jar - -sbt proguard -java -cp $CP org.junit.runner.JUnitCore scala.tools.jline.console.EditLineTest diff --git a/src/jline/project/build.properties b/src/jline/project/build.properties deleted file mode 100644 index 9b860e23c51a..000000000000 --- a/src/jline/project/build.properties +++ /dev/null @@ -1 +0,0 @@ -sbt.version=0.12.3 diff --git a/src/jline/project/plugins.sbt b/src/jline/project/plugins.sbt deleted file mode 100644 index 9c13de92d8ed..000000000000 --- a/src/jline/project/plugins.sbt +++ /dev/null @@ -1,3 +0,0 @@ -resolvers += Resolver.url("sbt-plugin-releases-scalasbt", url("http://repo.scala-sbt.org/scalasbt/sbt-plugin-releases/"))(Resolver.ivyStylePatterns) - -addSbtPlugin("org.scala-sbt" % "xsbt-proguard-plugin" % "0.1.3") diff --git a/src/jline/src/main/java/scala/tools/jline/AnsiWindowsTerminal.java b/src/jline/src/main/java/scala/tools/jline/AnsiWindowsTerminal.java deleted file mode 100644 index 94697137d307..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/AnsiWindowsTerminal.java +++ /dev/null @@ -1,90 +0,0 @@ -/* - * Copyright (C) 2009 the original author(s). - * - * 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. - * - * MODIFICATIONS: methods to deal with wrapping the output stream. - */ - -package scala.tools.jline; - -import org.fusesource.jansi.AnsiConsole; -import org.fusesource.jansi.AnsiOutputStream; -import org.fusesource.jansi.WindowsAnsiOutputStream; - -import java.io.ByteArrayOutputStream; -import java.io.OutputStream; - -/** - * ANSI-supported {@link WindowsTerminal}. - * - * @since 2.0 - */ -public class AnsiWindowsTerminal - extends WindowsTerminal -{ - private final boolean ansiSupported = detectAnsiSupport(); - - @Override - public OutputStream wrapOutIfNeeded(OutputStream out) { - return wrapOutputStream(out); - } - - /** - * Returns an ansi output stream handler. We return whatever was - * passed if we determine we cannot handle ansi based on Kernel32 calls. - * - * @return an @{link AltWindowAnsiOutputStream} instance or the passed - * stream. - */ - private static OutputStream wrapOutputStream(final OutputStream stream) { - String os = System.getProperty("os.name"); - if( os.startsWith("Windows") ) { - // On windows we know the console does not interpret ANSI codes.. - try { - return new WindowsAnsiOutputStream(stream); - } catch (Throwable ignore) { - // this happens when JNA is not in the path.. or - // this happens when the stdout is being redirected to a file. - } - // Use the ANSIOutputStream to strip out the ANSI escape sequences. - return new AnsiOutputStream(stream); - } - return stream; - } - - private static boolean detectAnsiSupport() { - OutputStream out = AnsiConsole.wrapOutputStream(new ByteArrayOutputStream()); - try { - out.close(); - } - catch (Exception e) { - // ignore; - } - return out instanceof WindowsAnsiOutputStream; - } - - public AnsiWindowsTerminal() throws Exception { - super(); - } - - @Override - public boolean isAnsiSupported() { - return ansiSupported; - } - - @Override - public boolean hasWeirdWrap() { - return false; - } -} diff --git a/src/jline/src/main/java/scala/tools/jline/NoInterruptUnixTerminal.java b/src/jline/src/main/java/scala/tools/jline/NoInterruptUnixTerminal.java deleted file mode 100644 index ef7cf23c4a3a..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/NoInterruptUnixTerminal.java +++ /dev/null @@ -1,44 +0,0 @@ -/* - * Copyright (C) 2009 the original author(s). - * - * 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 scala.tools.jline; - -// Based on Apache Karaf impl - -/** - * Non-interruptable (via CTRL-C) {@link UnixTerminal}. - * - * @since 2.0 - */ -public class NoInterruptUnixTerminal - extends UnixTerminal -{ - public NoInterruptUnixTerminal() throws Exception { - super(); - } - - @Override - public void init() throws Exception { - super.init(); - getSettings().set("intr undef"); - } - - @Override - public void restore() throws Exception { - getSettings().set("intr ^C"); - super.restore(); - } -} diff --git a/src/jline/src/main/java/scala/tools/jline/Terminal.java b/src/jline/src/main/java/scala/tools/jline/Terminal.java deleted file mode 100644 index 79611c244d0b..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/Terminal.java +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline; - -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; - -/** - * Representation of the input terminal for a platform. - * - * @author Marc Prud'hommeaux - * @author Jason Dillon - * @since 2.0 - */ -public interface Terminal -{ - void init() throws Exception; - - void restore() throws Exception; - - void reset() throws Exception; - - boolean isSupported(); - - int getWidth(); - - int getHeight(); - - boolean isAnsiSupported(); - - /** - * When ANSI is not natively handled, the output will have to be wrapped. - */ - OutputStream wrapOutIfNeeded(OutputStream out); - - /** - * For terminals that don't wrap when character is written in last column, - * only when the next character is written. - * These are the ones that have 'am' and 'xn' termcap attributes (xterm and - * rxvt flavors falls under that category) - */ - boolean hasWeirdWrap(); - - boolean isEchoEnabled(); - - void setEchoEnabled(boolean enabled); - - int readCharacter(InputStream in) throws IOException; - - int readVirtualKey(InputStream in) throws IOException; - - InputStream getDefaultBindings(); -} diff --git a/src/jline/src/main/java/scala/tools/jline/TerminalFactory.java b/src/jline/src/main/java/scala/tools/jline/TerminalFactory.java deleted file mode 100644 index 95b7c28bd555..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/TerminalFactory.java +++ /dev/null @@ -1,173 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline; - -import scala.tools.jline.internal.Configuration; -import scala.tools.jline.internal.Log; - -import java.text.MessageFormat; -import java.util.HashMap; -import java.util.Map; - -/** - * Creates terminal instances. - * - * @author Jason Dillon - * @since 2.0 - */ -public class TerminalFactory -{ - public static final String JLINE_TERMINAL = "jline.terminal"; - - public static final String AUTO = "auto"; - - public static final String UNIX = "unix"; - - public static final String WIN = "win"; - - public static final String WINDOWS = "windows"; - - public static final String NONE = "none"; - - public static final String OFF = "off"; - - public static final String FALSE = "false"; - - private static final InheritableThreadLocal holder = new InheritableThreadLocal(); - - public static synchronized Terminal create() { - if (Log.TRACE) { - //noinspection ThrowableInstanceNeverThrown - Log.trace(new Throwable("CREATE MARKER")); - } - - String type = Configuration.getString(JLINE_TERMINAL); - if (type == null) { - type = AUTO; - } - - Log.debug("Creating terminal; type=", type); - - Terminal t; - try { - String tmp = type.toLowerCase(); - - if (tmp.equals(UNIX)) { - t = getFlavor(Flavor.UNIX); - } - else if (tmp.equals(WIN) | tmp.equals(WINDOWS)) { - t = getFlavor(Flavor.WINDOWS); - } - else if (tmp.equals(NONE) || tmp.equals(OFF) || tmp.equals(FALSE)) { - t = new UnsupportedTerminal(); - } - else { - if (tmp.equals(AUTO)) { - String os = Configuration.getOsName(); - Flavor flavor = Flavor.UNIX; - if (os.contains(WINDOWS)) { - flavor = Flavor.WINDOWS; - } - t = getFlavor(flavor); - } - else { - try { - t = (Terminal) Thread.currentThread().getContextClassLoader().loadClass(type).newInstance(); - } - catch (Exception e) { - throw new IllegalArgumentException(MessageFormat.format("Invalid terminal type: {0}", type), e); - } - } - } - } - catch (Exception e) { - Log.error("Failed to construct terminal; falling back to unsupported", e); - t = new UnsupportedTerminal(); - } - - Log.debug("Created Terminal: ", t); - - try { - t.init(); - } - catch (Exception e) { - Log.error("Terminal initialization failed; falling back to unsupported", e); - return new UnsupportedTerminal(); - } - - return t; - } - - public static synchronized void reset() { - holder.remove(); - } - - public static synchronized void resetIf(final Terminal t) { - if (holder.get() == t) { - reset(); - } - } - - public static enum Type - { - AUTO, - WINDOWS, - UNIX, - NONE - } - - public static synchronized void configure(final String type) { - assert type != null; - System.setProperty(JLINE_TERMINAL, type); - } - - public static synchronized void configure(final Type type) { - assert type != null; - configure(type.name().toLowerCase()); - } - - // - // Flavor Support - // - - public static enum Flavor - { - WINDOWS, - UNIX - } - - private static final Map> FLAVORS = new HashMap>(); - - static { - registerFlavor(Flavor.WINDOWS, AnsiWindowsTerminal.class); - registerFlavor(Flavor.UNIX, UnixTerminal.class); - } - - public static synchronized Terminal get() { - Terminal t = holder.get(); - if (t == null) { - t = create(); - holder.set(t); - } - return t; - } - - public static Terminal getFlavor(final Flavor flavor) throws Exception { - Class type = FLAVORS.get(flavor); - if (type != null) { - return type.newInstance(); - } - - throw new InternalError(); - } - - public static void registerFlavor(final Flavor flavor, final Class type) { - FLAVORS.put(flavor, type); - } - -} \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/TerminalSupport.java b/src/jline/src/main/java/scala/tools/jline/TerminalSupport.java deleted file mode 100644 index 1ca12cb73f9c..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/TerminalSupport.java +++ /dev/null @@ -1,179 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline; - -import scala.tools.jline.internal.Log; -import scala.tools.jline.internal.Configuration; - -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; - -/** - * Provides support for {@link Terminal} instances. - * - * @author Jason Dillon - * @since 2.0 - */ -public abstract class TerminalSupport - implements Terminal -{ - public static String DEFAULT_KEYBINDINGS_PROPERTIES = "keybindings.properties"; - - public static final String JLINE_SHUTDOWNHOOK = "jline.shutdownhook"; - - public static final int DEFAULT_WIDTH = 80; - - public static final int DEFAULT_HEIGHT = 24; - - private Thread shutdownHook; - - private boolean shutdownHookEnabled; - - private boolean supported; - - private boolean echoEnabled; - - private boolean ansiSupported; - - protected TerminalSupport(final boolean supported) { - this.supported = supported; - this.shutdownHookEnabled = Configuration.getBoolean(JLINE_SHUTDOWNHOOK, false); - } - - public void init() throws Exception { - installShutdownHook(new RestoreHook()); - } - - public void restore() throws Exception { - TerminalFactory.resetIf(this); - removeShutdownHook(); - } - - public void reset() throws Exception { - restore(); - init(); - } - - // Shutdown hooks causes classloader leakage in sbt, - // so they are only installed if -Djline.shutdownhook is true. - protected void installShutdownHook(final Thread hook) { - if (!shutdownHookEnabled) { - Log.debug("Not install shutdown hook " + hook + " because they are disabled."); - return; - } - - assert hook != null; - - if (shutdownHook != null) { - throw new IllegalStateException("Shutdown hook already installed"); - } - - try { - Runtime.getRuntime().addShutdownHook(hook); - shutdownHook = hook; - } - catch (AbstractMethodError e) { - // JDK 1.3+ only method. Bummer. - Log.trace("Failed to register shutdown hook: ", e); - } - } - - protected void removeShutdownHook() { - if (!shutdownHookEnabled) - return; - - if (shutdownHook != null) { - try { - Runtime.getRuntime().removeShutdownHook(shutdownHook); - } - catch (AbstractMethodError e) { - // JDK 1.3+ only method. Bummer. - Log.trace("Failed to remove shutdown hook: ", e); - } - catch (IllegalStateException e) { - // The VM is shutting down, not a big deal; ignore - } - shutdownHook = null; - } - } - - public final boolean isSupported() { - return supported; - } - - public synchronized boolean isAnsiSupported() { - return ansiSupported; - } - - protected synchronized void setAnsiSupported(final boolean supported) { - this.ansiSupported = supported; - Log.debug("Ansi supported: ", supported); - } - - /** - * Subclass to change behavior if needed. - * @return the passed out - */ - public OutputStream wrapOutIfNeeded(OutputStream out) { - return out; - } - - /** - * Defaults to true which was the behaviour before this method was added. - */ - public boolean hasWeirdWrap() { - return true; - } - - public int getWidth() { - return DEFAULT_WIDTH; - } - - public int getHeight() { - return DEFAULT_HEIGHT; - } - - public synchronized boolean isEchoEnabled() { - return echoEnabled; - } - - public synchronized void setEchoEnabled(final boolean enabled) { - this.echoEnabled = enabled; - Log.debug("Echo enabled: ", enabled); - } - - public int readCharacter(final InputStream in) throws IOException { - return in.read(); - } - - public int readVirtualKey(final InputStream in) throws IOException { - return readCharacter(in); - } - - public InputStream getDefaultBindings() { - return TerminalSupport.class.getResourceAsStream(DEFAULT_KEYBINDINGS_PROPERTIES); - } - - // - // RestoreHook - // - - protected class RestoreHook - extends Thread - { - public void start() { - try { - restore(); - } - catch (Exception e) { - Log.trace("Failed to restore: ", e); - } - } - } -} \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/UnixTerminal.java b/src/jline/src/main/java/scala/tools/jline/UnixTerminal.java deleted file mode 100644 index 94a1b98c0d09..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/UnixTerminal.java +++ /dev/null @@ -1,248 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline; - -import scala.tools.jline.console.Key; -import scala.tools.jline.internal.Configuration; -import scala.tools.jline.internal.Log; -import scala.tools.jline.internal.ReplayPrefixOneCharInputStream; -import scala.tools.jline.internal.TerminalLineSettings; - -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.util.HashMap; -import java.util.Map; - -import static scala.tools.jline.UnixTerminal.UnixKey.*; -import static scala.tools.jline.console.Key.*; - -/** - * Terminal that is used for unix platforms. Terminal initialization - * is handled by issuing the stty command against the - * /dev/tty file to disable character echoing and enable - * character input. All known unix systems (including - * Linux and Macintosh OS X) support the stty), so this - * implementation should work for an reasonable POSIX system. - * - * @author Marc Prud'hommeaux - * @author Dale Kemp - * @author Jason Dillon - * @author Jean-Baptiste Onofré - * @since 2.0 - */ -public class UnixTerminal - extends TerminalSupport -{ - private final TerminalLineSettings settings = new TerminalLineSettings(); - - private final ReplayPrefixOneCharInputStream replayStream; - - private final InputStreamReader replayReader; - - public UnixTerminal() throws Exception { - super(true); - - this.replayStream = new ReplayPrefixOneCharInputStream(Configuration.getInputEncoding()); - this.replayReader = new InputStreamReader(replayStream, replayStream.getEncoding()); - } - - protected TerminalLineSettings getSettings() { - return settings; - } - - /** - * Remove line-buffered input by invoking "stty -icanon min 1" - * against the current terminal. - */ - @Override - public void init() throws Exception { - super.init(); - - setAnsiSupported(true); - - // set the console to be character-buffered instead of line-buffered - settings.set("-icanon min 1"); - - setEchoEnabled(false); - } - - /** - * Restore the original terminal configuration, which can be used when - * shutting down the console reader. The ConsoleReader cannot be - * used after calling this method. - */ - @Override - public void restore() throws Exception { - settings.restore(); - super.restore(); - // print a newline after the terminal exits. - // this should probably be a configurable. - System.out.println(); - } - - /** - * Returns the value of stty columns param. - */ - @Override - public int getWidth() { - int w = settings.getProperty("columns"); - return w < 1 ? DEFAULT_WIDTH : w; - } - - /** - * Returns the value of stty rows>/tt> param. - */ - @Override - public int getHeight() { - int h = settings.getProperty("rows"); - return h < 1 ? DEFAULT_HEIGHT : h; - } - - @Override - public synchronized void setEchoEnabled(final boolean enabled) { - try { - if (enabled) { - settings.set("echo"); - } - else { - settings.set("-echo"); - } - super.setEchoEnabled(enabled); - } - catch (Exception e) { - Log.error("Failed to ", (enabled ? "enable" : "disable"), " echo: ", e); - } - } - - @Override - public int readVirtualKey(final InputStream in) throws IOException { - int c = readCharacter(in); - - if (Key.valueOf(c) == DELETE && settings.getProperty("erase") == DELETE.code) { - c = BACKSPACE.code; - } - - UnixKey key = UnixKey.valueOf(c); - - // in Unix terminals, arrow keys are represented by a sequence of 3 characters. E.g., the up arrow key yields 27, 91, 68 - if (key == ARROW_START) { - // also the escape key is 27 thats why we read until we have something different than 27 - // this is a bugfix, because otherwise pressing escape and than an arrow key was an undefined state - while (key == ARROW_START) { - c = readCharacter(in); - key = UnixKey.valueOf(c); - } - - if (key == ARROW_PREFIX || key == O_PREFIX) { - c = readCharacter(in); - key = UnixKey.valueOf(c); - - if (key == ARROW_UP) { - return CTRL_P.code; - } - else if (key == ARROW_DOWN) { - return CTRL_N.code; - } - else if (key == ARROW_LEFT) { - return CTRL_B.code; - } - else if (key == ARROW_RIGHT) { - return CTRL_F.code; - } - else if (key == HOME_CODE) { - return CTRL_A.code; - } - else if (key == END_CODE) { - return CTRL_E.code; - } - else if (key == DEL_THIRD) { - readCharacter(in); // read 4th & ignore - return DELETE.code; - } - } - else if (c == 'b') { // alt-b: go back a word - return CTRL_O.code; // PREV_WORD - } - else if (c == 'f') { // alt-f: go forward a word - return CTRL_T.code; // NEXT_WORD - } - else if (key == DEL) { // alt-backspace: delete previous word - return CTRL_W.code; // DELETE_PREV_WORD - } - else if (c == 'd') { // alt-d: delete next word - return CTRL_X.code; // DELETE_NEXT_WORD - } - - } - - // handle unicode characters, thanks for a patch from amyi@inf.ed.ac.uk - if (c > 128) { - // handle unicode characters longer than 2 bytes, - // thanks to Marc.Herbert@continuent.com - replayStream.setInput(c, in); - // replayReader = new InputStreamReader(replayStream, encoding); - c = replayReader.read(); - } - - return c; - } - - /** - * Unix keys. - */ - public static enum UnixKey - { - ARROW_START(27), - - ARROW_PREFIX(91), - - ARROW_LEFT(68), - - ARROW_RIGHT(67), - - ARROW_UP(65), - - ARROW_DOWN(66), - - O_PREFIX(79), - - HOME_CODE(72), - - END_CODE(70), - - DEL_THIRD(51), - - DEL_SECOND(126), - - DEL(127); - - - public final short code; - - UnixKey(final int code) { - this.code = (short) code; - } - - private static final Map codes; - - static { - Map map = new HashMap(); - - for (UnixKey key : UnixKey.values()) { - map.put(key.code, key); - } - - codes = map; - } - - public static UnixKey valueOf(final int code) { - return codes.get((short) code); - } - } -} \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/UnsupportedTerminal.java b/src/jline/src/main/java/scala/tools/jline/UnsupportedTerminal.java deleted file mode 100644 index 04fe4f7f1612..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/UnsupportedTerminal.java +++ /dev/null @@ -1,25 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline; - -/** - * An unsupported terminal. - * - * @author Marc Prud'hommeaux - * @author Jason Dillon - * @since 2.0 - */ -public class UnsupportedTerminal - extends TerminalSupport -{ - public UnsupportedTerminal() { - super(false); - setAnsiSupported(false); - setEchoEnabled(true); - } -} diff --git a/src/jline/src/main/java/scala/tools/jline/WindowsTerminal.java b/src/jline/src/main/java/scala/tools/jline/WindowsTerminal.java deleted file mode 100644 index 4c70155f59fb..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/WindowsTerminal.java +++ /dev/null @@ -1,468 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline; - -import java.io.FileDescriptor; -import java.io.FileInputStream; -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.util.HashMap; -import java.util.Map; - -import scala.tools.jline.internal.Configuration; -import org.fusesource.jansi.internal.WindowsSupport; - -import scala.tools.jline.internal.Log; -import scala.tools.jline.internal.ReplayPrefixOneCharInputStream; - -import static scala.tools.jline.WindowsTerminal.ConsoleMode.*; -import static scala.tools.jline.WindowsTerminal.WindowsKey.*; -import static scala.tools.jline.console.Key.*; - -/** - * Terminal implementation for Microsoft Windows. Terminal initialization in - * {@link #init} is accomplished by extracting the - * jline_version.dll, saving it to the system temporary - * directoy (determined by the setting of the java.io.tmpdir System - * property), loading the library, and then calling the Win32 APIs SetConsoleMode and - * GetConsoleMode to - * disable character echoing. - *

    - *

    - * By default, the {@link #readCharacter} method will attempt to test to see if - * the specified {@link InputStream} is {@link System#in} or a wrapper around - * {@link FileDescriptor#in}, and if so, will bypass the character reading to - * directly invoke the readc() method in the JNI library. This is so the class - * can read special keys (like arrow keys) which are otherwise inaccessible via - * the {@link System#in} stream. Using JNI reading can be bypassed by setting - * the jline.WindowsTerminal.directConsole system property - * to false. - *

    - * - * @author Marc Prud'hommeaux - * @author Jason Dillon - * @since 2.0 - */ -public class WindowsTerminal - extends TerminalSupport -{ - public static final String JLINE_WINDOWS_TERMINAL_INPUT_ENCODING = "jline.WindowsTerminal.input.encoding"; - - public static final String JLINE_WINDOWS_TERMINAL_OUTPUT_ENCODING = "jline.WindowsTerminal.output.encoding"; - - public static final String JLINE_WINDOWS_TERMINAL_DIRECT_CONSOLE = "jline.WindowsTerminal.directConsole"; - - public static final String WINDOWSBINDINGS_PROPERTIES = "windowsbindings.properties"; - - public static final String ANSI = WindowsTerminal.class.getName() + ".ansi"; - - private boolean directConsole; - - private int originalMode; - - private final ReplayPrefixOneCharInputStream replayStream; - - private final InputStreamReader replayReader; - - public WindowsTerminal() throws Exception { - super(true); - - this.replayStream = - new ReplayPrefixOneCharInputStream(Configuration.getString(JLINE_WINDOWS_TERMINAL_INPUT_ENCODING, Configuration.getFileEncoding())); - this.replayReader = new InputStreamReader(replayStream, replayStream.getEncoding()); - } - - @Override - public void init() throws Exception { - super.init(); - - setAnsiSupported(Boolean.getBoolean(ANSI)); - - // - // FIXME: Need a way to disable direct console and sysin detection muck - // - - setDirectConsole(Boolean.getBoolean(JLINE_WINDOWS_TERMINAL_DIRECT_CONSOLE)); - - this.originalMode = getConsoleMode(); - setConsoleMode(originalMode & ~ENABLE_ECHO_INPUT.code); - setEchoEnabled(false); - } - - /** - * Restore the original terminal configuration, which can be used when - * shutting down the console reader. The ConsoleReader cannot be - * used after calling this method. - */ - @Override - public void restore() throws Exception { - // restore the old console mode - setConsoleMode(originalMode); - super.restore(); - } - - @Override - public int getWidth() { - int w = getWindowsTerminalWidth(); - return w < 1 ? DEFAULT_WIDTH : w; - } - - @Override - public int getHeight() { - int h = getWindowsTerminalHeight(); - return h < 1 ? DEFAULT_HEIGHT : h; - } - - @Override - public void setEchoEnabled(final boolean enabled) { - // Must set these four modes at the same time to make it work fine. - if (enabled) { - setConsoleMode(getConsoleMode() | - ENABLE_ECHO_INPUT.code | - ENABLE_LINE_INPUT.code | - ENABLE_PROCESSED_INPUT.code | - ENABLE_WINDOW_INPUT.code); - } - else { - setConsoleMode(getConsoleMode() & - ~(ENABLE_LINE_INPUT.code | - ENABLE_ECHO_INPUT.code | - ENABLE_PROCESSED_INPUT.code | - ENABLE_WINDOW_INPUT.code)); - } - super.setEchoEnabled(enabled); - } - - /** - * Whether or not to allow the use of the JNI console interaction. - */ - public void setDirectConsole(final boolean flag) { - this.directConsole = flag; - Log.debug("Direct console: ", flag); - } - - /** - * Whether or not to allow the use of the JNI console interaction. - */ - public Boolean getDirectConsole() { - return directConsole; - } - - - @Override - public int readCharacter(final InputStream in) throws IOException { - // if we can detect that we are directly wrapping the system - // input, then bypass the input stream and read directly (which - // allows us to access otherwise unreadable strokes, such as - // the arrow keys) - - if (directConsole || isSystemIn(in)) { - return readByte(); - } - else { - return super.readCharacter(in); - } - } - - private boolean isSystemIn(final InputStream in) throws IOException { - assert in != null; - - if (in == System.in) { - return true; - } - else if (in instanceof FileInputStream && ((FileInputStream) in).getFD() == FileDescriptor.in) { - return true; - } - - return false; - } - - @Override - public int readVirtualKey(final InputStream in) throws IOException { - int indicator = readCharacter(in); - - // in Windows terminals, arrow keys are represented by - // a sequence of 2 characters. E.g., the up arrow - // key yields 224, 72 - if (indicator == SPECIAL_KEY_INDICATOR.code || indicator == NUMPAD_KEY_INDICATOR.code) { - int c = readCharacter(in); - WindowsKey key = WindowsKey.valueOf(c); - if (key == null) - return 0; - - switch (key) { - case UP_ARROW_KEY: - return CTRL_P.code; // translate UP -> CTRL-P - - case LEFT_ARROW_KEY: - return CTRL_B.code; // translate LEFT -> CTRL-B - - case RIGHT_ARROW_KEY: - return CTRL_F.code; // translate RIGHT -> CTRL-F - - case DOWN_ARROW_KEY: - return CTRL_N.code; // translate DOWN -> CTRL-N - - case DELETE_KEY: - return CTRL_QM.code; // translate DELETE -> CTRL-? - - case HOME_KEY: - return CTRL_A.code; - - case END_KEY: - return CTRL_E.code; - - case PAGE_UP_KEY: - return CTRL_K.code; - - case PAGE_DOWN_KEY: - return CTRL_L.code; - - case ESCAPE_KEY: - return CTRL_OB.code; // translate ESCAPE -> CTRL-[ - - case INSERT_KEY: - return CTRL_C.code; - - default: - return 0; - } - } - else if (indicator > 128) { - // handle unicode characters longer than 2 bytes, - // thanks to Marc.Herbert@continuent.com - replayStream.setInput(indicator, in); - // replayReader = new InputStreamReader(replayStream, encoding); - indicator = replayReader.read(); - - } - - return indicator; - } - - @Override - public InputStream getDefaultBindings() { - return WindowsTerminal.class.getResourceAsStream(WINDOWSBINDINGS_PROPERTIES); - } - - // - // Native Bits - // - private int getConsoleMode() { - return WindowsSupport.getConsoleMode(); - } - - private void setConsoleMode(int mode) { - WindowsSupport.setConsoleMode(mode); - } - - private int readByte() { - return WindowsSupport.readByte(); - } - - private int getWindowsTerminalWidth() { - return WindowsSupport.getWindowsTerminalWidth(); - } - - private int getWindowsTerminalHeight() { - return WindowsSupport.getWindowsTerminalHeight(); - } - - /** - * Console mode - *

    - * Constants copied wincon.h. - */ - public static enum ConsoleMode - { - /** - * The ReadFile or ReadConsole function returns only when a carriage return - * character is read. If this mode is disable, the functions return when one - * or more characters are available. - */ - ENABLE_LINE_INPUT(2), - - /** - * Characters read by the ReadFile or ReadConsole function are written to - * the active screen buffer as they are read. This mode can be used only if - * the ENABLE_LINE_INPUT mode is also enabled. - */ - ENABLE_ECHO_INPUT(4), - - /** - * CTRL+C is processed by the system and is not placed in the input buffer. - * If the input buffer is being read by ReadFile or ReadConsole, other - * control keys are processed by the system and are not returned in the - * ReadFile or ReadConsole buffer. If the ENABLE_LINE_INPUT mode is also - * enabled, backspace, carriage return, and linefeed characters are handled - * by the system. - */ - ENABLE_PROCESSED_INPUT(1), - - /** - * User interactions that change the size of the console screen buffer are - * reported in the console's input buffee. Information about these events - * can be read from the input buffer by applications using - * theReadConsoleInput function, but not by those using ReadFile - * orReadConsole. - */ - ENABLE_WINDOW_INPUT(8), - - /** - * If the mouse pointer is within the borders of the console window and the - * window has the keyboard focus, mouse events generated by mouse movement - * and button presses are placed in the input buffer. These events are - * discarded by ReadFile or ReadConsole, even when this mode is enabled. - */ - ENABLE_MOUSE_INPUT(16), - - /** - * When enabled, text entered in a console window will be inserted at the - * current cursor location and all text following that location will not be - * overwritten. When disabled, all following text will be overwritten. An OR - * operation must be performed with this flag and the ENABLE_EXTENDED_FLAGS - * flag to enable this functionality. - */ - ENABLE_PROCESSED_OUTPUT(1), - - /** - * This flag enables the user to use the mouse to select and edit text. To - * enable this option, use the OR to combine this flag with - * ENABLE_EXTENDED_FLAGS. - */ - ENABLE_WRAP_AT_EOL_OUTPUT(2),; - - public final int code; - - ConsoleMode(final int code) { - this.code = code; - } - } - - /** - * Windows keys. - *

    - * Constants copied wincon.h. - */ - public static enum WindowsKey - { - /** - * On windows terminals, this character indicates that a 'special' key has - * been pressed. This means that a key such as an arrow key, or delete, or - * home, etc. will be indicated by the next character. - */ - SPECIAL_KEY_INDICATOR(224), - - /** - * On windows terminals, this character indicates that a special key on the - * number pad has been pressed. - */ - NUMPAD_KEY_INDICATOR(0), - - /** - * When following the SPECIAL_KEY_INDICATOR or NUMPAD_KEY_INDICATOR, - * this character indicates an left arrow key press. - */ - LEFT_ARROW_KEY(75), - - /** - * When following the SPECIAL_KEY_INDICATOR or NUMPAD_KEY_INDICATOR - * this character indicates an - * right arrow key press. - */ - RIGHT_ARROW_KEY(77), - - /** - * When following the SPECIAL_KEY_INDICATOR or NUMPAD_KEY_INDICATOR - * this character indicates an up - * arrow key press. - */ - UP_ARROW_KEY(72), - - /** - * When following the SPECIAL_KEY_INDICATOR or NUMPAD_KEY_INDICATOR - * this character indicates an - * down arrow key press. - */ - DOWN_ARROW_KEY(80), - - /** - * When following the SPECIAL_KEY_INDICATOR or NUMPAD_KEY_INDICATOR - * this character indicates that - * the delete key was pressed. - */ - DELETE_KEY(83), - - /** - * When following the SPECIAL_KEY_INDICATOR or NUMPAD_KEY_INDICATOR - * this character indicates that - * the home key was pressed. - */ - HOME_KEY(71), - - /** - * When following the SPECIAL_KEY_INDICATOR or NUMPAD_KEY_INDICATOR - * this character indicates that - * the end key was pressed. - */ - END_KEY(79), - - /** - * When following the SPECIAL_KEY_INDICATOR or NUMPAD_KEY_INDICATOR - * this character indicates that - * the page up key was pressed. - */ - PAGE_UP_KEY(73), - - /** - * When following the SPECIAL_KEY_INDICATOR or NUMPAD_KEY_INDICATOR - * this character indicates that - * the page down key was pressed. - */ - PAGE_DOWN_KEY(81), - - /** - * When following the SPECIAL_KEY_INDICATOR or NUMPAD_KEY_INDICATOR - * this character indicates that - * the insert key was pressed. - */ - INSERT_KEY(82), - - /** - * When following the SPECIAL_KEY_INDICATOR or NUMPAD_KEY_INDICATOR, - * this character indicates that the escape key was pressed. - */ - ESCAPE_KEY(0),; - - public final int code; - - WindowsKey(final int code) { - this.code = code; - } - - private static final Map codes; - - static { - Map map = new HashMap(); - - for (WindowsKey key : WindowsKey.values()) { - map.put(key.code, key); - } - - codes = map; - } - - public static WindowsKey valueOf(final int code) { - return codes.get(code); - } - } -} diff --git a/src/jline/src/main/java/scala/tools/jline/console/ConsoleReader.java b/src/jline/src/main/java/scala/tools/jline/console/ConsoleReader.java deleted file mode 100644 index a375b84a5cee..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/ConsoleReader.java +++ /dev/null @@ -1,2185 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline.console; - -import scala.tools.jline.Terminal; -import scala.tools.jline.TerminalFactory; -import scala.tools.jline.console.completer.CandidateListCompletionHandler; -import scala.tools.jline.console.completer.Completer; -import scala.tools.jline.console.completer.CompletionHandler; -import scala.tools.jline.console.history.History; -import scala.tools.jline.console.history.MemoryHistory; -import scala.tools.jline.internal.Configuration; -import scala.tools.jline.internal.Log; -import org.fusesource.jansi.AnsiOutputStream; - -import java.awt.Toolkit; -import java.awt.datatransfer.Clipboard; -import java.awt.datatransfer.DataFlavor; -import java.awt.datatransfer.Transferable; -import java.awt.datatransfer.UnsupportedFlavorException; -import java.awt.event.ActionListener; -import java.io.*; -import java.util.*; - -/** - * A reader for console applications. It supports custom tab-completion, - * saveable command history, and command line editing. On some platforms, - * platform-specific commands will need to be issued before the reader will - * function properly. See {@link jline.Terminal#init} for convenience - * methods for issuing platform-specific setup commands. - * - * @author Marc Prud'hommeaux - * @author Jason Dillon - */ -public class ConsoleReader -{ - public static final String JLINE_NOBELL = "jline.nobell"; - - public static final String JLINE_EXPANDEVENTS = "jline.expandevents"; - - public static final char BACKSPACE = '\b'; - - public static final char RESET_LINE = '\r'; - - public static final char KEYBOARD_BELL = '\07'; - - public static final char NULL_MASK = 0; - - public static final int TAB_WIDTH = 4; - - private static final ResourceBundle - resources = ResourceBundle.getBundle(CandidateListCompletionHandler.class.getName()); - - private final Terminal terminal; - - private InputStream in; - - private final Writer out; - - private final CursorBuffer buf = new CursorBuffer(); - - private String prompt; - - private boolean bellEnabled = true; - - private boolean expandEvents = false; - - private Character mask; - - private Character echoCharacter; - - private StringBuffer searchTerm = null; - - private String previousSearchTerm = ""; - - private int searchIndex = -1; - - public ConsoleReader(final InputStream in, final OutputStream out, final InputStream bindings, final Terminal term) throws - IOException - { - this.in = in; - this.terminal = term != null ? term : TerminalFactory.get(); - this.out = new PrintWriter(getTerminal().wrapOutIfNeeded(out)); - this.keyBindings = loadKeyBindings(bindings); - - setBellEnabled(!Configuration.getBoolean(JLINE_NOBELL, false)); - setExpandEvents(Configuration.getBoolean(JLINE_EXPANDEVENTS, false)); - } - - /** - * @deprecated use {@link #ConsoleReader(InputStream, OutputStream, InputStream, Terminal)} - * to let the terminal wrap the output stream if needed. - */ - public ConsoleReader(final InputStream in, final Writer out, final InputStream bindings, final Terminal term) throws - IOException - { - this.in = in; - this.out = out; - this.terminal = term != null ? term : TerminalFactory.get(); - this.keyBindings = loadKeyBindings(bindings); - - setBellEnabled(!Configuration.getBoolean(JLINE_NOBELL, false)); - } - - /** - * @deprecated use {@link #ConsoleReader(InputStream, OutputStream, InputStream, Terminal)} - * to let the terminal wrap the output stream if needed. - */ - public ConsoleReader(final InputStream in, final Writer out, final Terminal term) throws IOException { - this(in, out, null, term); - } - - /** - * @deprecated use {@link #ConsoleReader(InputStream, OutputStream, InputStream, Terminal)} - * to let the terminal wrap the output stream if needed. - */ - public ConsoleReader(final InputStream in, final Writer out) throws IOException - { - this(in, out, null, null); - } - - /** - * Create a new reader using {@link FileDescriptor#in} for input and - * {@link System#out} for output. - *

    - * {@link FileDescriptor#in} is used because it has a better chance of not being buffered. - */ - public ConsoleReader() throws IOException { - this(new FileInputStream(FileDescriptor.in), System.out, null, null ); - } - - // FIXME: Only used for tests - - void setInput(final InputStream in) { - this.in = in; - } - - public InputStream getInput() { - return in; - } - - public Writer getOutput() { - return out; - } - - public Terminal getTerminal() { - return terminal; - } - - public CursorBuffer getCursorBuffer() { - return buf; - } - - public void setBellEnabled(final boolean enabled) { - this.bellEnabled = enabled; - } - - public boolean isBellEnabled() { - return bellEnabled; - } - - public void setExpandEvents(final boolean expand) { - this.expandEvents = expand; - } - - public boolean getExpandEvents() { - return expandEvents; - } - - public void setPrompt(final String prompt) { - this.prompt = prompt; - } - - public String getPrompt() { - return prompt; - } - - /** - * Set the echo character. For example, to have "*" entered when a password is typed: - *

    - * 

    -     * myConsoleReader.setEchoCharacter(new Character('*'));
-     *
    - *

    - * Setting the character to - *

    - * 

    -     * null
-     *
    - *

    - * will restore normal character echoing. Setting the character to - *

    - * 

    -     * new Character(0)
-     *
    - *

    - * will cause nothing to be echoed. - * - * @param c the character to echo to the console in place of the typed character. - */ - public void setEchoCharacter(final Character c) { - this.echoCharacter = c; - } - - /** - * Returns the echo character. - */ - public Character getEchoCharacter() { - return echoCharacter; - } - - /** - * Erase the current line. - * - * @return false if we failed (e.g., the buffer was empty) - */ - protected final boolean resetLine() throws IOException { - if (buf.cursor == 0) { - return false; - } - - backspaceAll(); - - return true; - } - - int getCursorPosition() { - // FIXME: does not handle anything but a line with a prompt absolute position - String prompt = getPrompt(); - return ((prompt == null) ? 0 : stripAnsi(lastLine(prompt)).length()) + buf.cursor; - } - - /** - * Returns the text after the last '\n'. - * prompt is returned if no '\n' characters are present. - * null is returned if prompt is null. - */ - private String lastLine(String str) { - if (str == null) return ""; - int last = str.lastIndexOf("\n"); - - if (last >= 0) { - return str.substring(last + 1, str.length()); - } - - return str; - } - - private String stripAnsi(String str) { - if (str == null) return ""; - try { - ByteArrayOutputStream baos = new ByteArrayOutputStream(); - AnsiOutputStream aos = new AnsiOutputStream(baos); - aos.write(str.getBytes()); - aos.flush(); - return baos.toString(); - } catch (IOException e) { - return str; - } - } - - /** - * Move the cursor position to the specified absolute index. - */ - public final boolean setCursorPosition(final int position) throws IOException { - return moveCursor(position - buf.cursor) != 0; - } - - /** - * Set the current buffer's content to the specified {@link String}. The - * visual console will be modified to show the current buffer. - * - * @param buffer the new contents of the buffer. - */ - private void setBuffer(final String buffer) throws IOException { - // don't bother modifying it if it is unchanged - if (buffer.equals(buf.buffer.toString())) { - return; - } - - // obtain the difference between the current buffer and the new one - int sameIndex = 0; - - for (int i = 0, l1 = buffer.length(), l2 = buf.buffer.length(); (i < l1) - && (i < l2); i++) { - if (buffer.charAt(i) == buf.buffer.charAt(i)) { - sameIndex++; - } - else { - break; - } - } - - int diff = buf.cursor - sameIndex; - if (diff < 0) { // we can't backspace here so try from the end of the buffer - moveToEnd(); - diff = buf.buffer.length() - sameIndex; - } - - backspace(diff); // go back for the differences - killLine(); // clear to the end of the line - buf.buffer.setLength(sameIndex); // the new length - putString(buffer.substring(sameIndex)); // append the differences - } - - private void setBuffer(final CharSequence buffer) throws IOException { - setBuffer(String.valueOf(buffer)); - } - - /** - * Output put the prompt + the current buffer - */ - public final void drawLine() throws IOException { - String prompt = getPrompt(); - if (prompt != null) { - print(prompt); - } - - print(buf.buffer.toString()); - - if (buf.length() != buf.cursor) { // not at end of line - back(buf.length() - buf.cursor - 1); - } - // force drawBuffer to check for weird wrap (after clear screen) - drawBuffer(); - } - - /** - * Clear the line and redraw it. - */ - public final void redrawLine() throws IOException { - print(RESET_LINE); -// flush(); - drawLine(); - } - - /** - * Clear the buffer and add its contents to the history. - * - * @return the former contents of the buffer. - */ - final String finishBuffer() throws IOException { // FIXME: Package protected because used by tests - String str = buf.buffer.toString(); - - if (expandEvents) { - str = expandEvents(str); - } - - // we only add it to the history if the buffer is not empty - // and if mask is null, since having a mask typically means - // the string was a password. We clear the mask after this call - if (str.length() > 0) { - if (mask == null && isHistoryEnabled()) { - history.add(str); - } - else { - mask = null; - } - } - - history.moveToEnd(); - - buf.buffer.setLength(0); - buf.cursor = 0; - - return str; - } - - /** - * Expand event designator such as !!, !#, !3, etc... - * See http://www.gnu.org/software/bash/manual/html_node/Event-Designators.html - * - * @param str - * @return - */ - protected String expandEvents(String str) throws IOException { - StringBuilder sb = new StringBuilder(); - for (int i = 0; i < str.length(); i++) { - char c = str.charAt(i); - switch (c) { - case '!': - if (i + 1 < str.length()) { - c = str.charAt(++i); - boolean neg = false; - String rep = null; - int i1, idx; - switch (c) { - case '!': - if (history.size() == 0) { - throw new IllegalArgumentException("!!: event not found"); - } - rep = history.get(history.index() - 1).toString(); - break; - case '#': - sb.append(sb.toString()); - break; - case '?': - i1 = str.indexOf('?', i + 1); - if (i1 < 0) { - i1 = str.length(); - } - String sc = str.substring(i + 1, i1); - i = i1; - idx = searchBackwards(sc); - if (idx < 0) { - throw new IllegalArgumentException("!?" + sc + ": event not found"); - } else { - rep = history.get(idx).toString(); - } - break; - case ' ': - case '\t': - sb.append('!'); - sb.append(c); - break; - case '-': - neg = true; - i++; - // fall through - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - i1 = i; - for (; i < str.length(); i++) { - c = str.charAt(i); - if (c < '0' || c > '9') { - break; - } - } - idx = 0; - try { - idx = Integer.parseInt(str.substring(i1, i)); - } catch (NumberFormatException e) { - throw new IllegalArgumentException((neg ? "!-" : "!") + str.substring(i1, i) + ": event not found"); - } - if (neg) { - if (idx < history.size()) { - rep = (history.get(history.index() - idx)).toString(); - } else { - throw new IllegalArgumentException((neg ? "!-" : "!") + str.substring(i1, i) + ": event not found"); - } - } else { - if (idx >= history.index() - history.size() && idx < history.index()) { - rep = (history.get(idx)).toString(); - } else { - throw new IllegalArgumentException((neg ? "!-" : "!") + str.substring(i1, i) + ": event not found"); - } - } - break; - default: - String ss = str.substring(i); - i = str.length(); - idx = searchBackwards(ss, history.index(), true); - if (idx < 0) { - throw new IllegalArgumentException("!" + ss + ": event not found"); - } else { - rep = history.get(idx).toString(); - } - break; - } - if (rep != null) { - sb.append(rep); - } - } else { - sb.append(c); - } - break; - case '^': - if (i == 0) { - int i1 = str.indexOf('^', i + 1); - int i2 = str.indexOf('^', i1 + 1); - if (i2 < 0) { - i2 = str.length(); - } - if (i1 > 0 && i2 > 0) { - String s1 = str.substring(i + 1, i1); - String s2 = str.substring(i1 + 1, i2); - String s = history.get(history.index() - 1).toString().replace(s1, s2); - sb.append(s); - i = i2 + 1; - break; - } - } - sb.append(c); - break; - default: - sb.append(c); - break; - } - } - String result = sb.toString(); - if (!str.equals(result)) { - print(result); - println(); - flush(); - } - return result; - - } - - /** - * Write out the specified string to the buffer and the output stream. - */ - public final void putString(final CharSequence str) throws IOException { - buf.write(str); - print(str); - drawBuffer(); - } - - /** - * Output the specified character, both to the buffer and the output stream. - */ - private void putChar(final int c, final boolean print) throws IOException { - buf.write((char) c); - - if (print) { - if (mask == null) { - // no masking - print(c); - } - else if (mask == NULL_MASK) { - // Don't print anything - } - else { - print(mask); - } - - drawBuffer(); - } - } - - /** - * Redraw the rest of the buffer from the cursor onwards. This is necessary - * for inserting text into the buffer. - * - * @param clear the number of characters to clear after the end of the buffer - */ - private void drawBuffer(final int clear) throws IOException { - // debug ("drawBuffer: " + clear); - if (buf.cursor == buf.length() && clear == 0) { - } else { - char[] chars = buf.buffer.substring(buf.cursor).toCharArray(); - if (mask != null) { - Arrays.fill(chars, mask); - } - if (getTerminal().hasWeirdWrap()) { - // need to determine if wrapping will occur: - int width = getTerminal().getWidth(); - int pos = getCursorPosition(); - for (int i = 0; i < chars.length; i++) { - print(chars[i]); - if ((pos + i + 1) % width == 0) { - print(32); // move cursor to next line by printing dummy space - print(13); // CR / not newline. - } - } - } else { - print(chars); - } - clearAhead(clear, chars.length); - if (getTerminal().isAnsiSupported()) { - if (chars.length > 0) { - back(chars.length); - } - } else { - back(chars.length); - } - } - if (getTerminal().hasWeirdWrap()) { - int width = getTerminal().getWidth(); - // best guess on whether the cursor is in that weird location... - // Need to do this without calling ansi cursor location methods - // otherwise it breaks paste of wrapped lines in xterm. - if (getCursorPosition() > 0 && (getCursorPosition() % width == 0) - && buf.cursor == buf.length() && clear == 0) { - // the following workaround is reverse-engineered from looking - // at what bash sent to the terminal in the same situation - print(32); // move cursor to next line by printing dummy space - print(13); // CR / not newline. - } - } - } - - /** - * Redraw the rest of the buffer from the cursor onwards. This is necessary - * for inserting text into the buffer. - */ - private void drawBuffer() throws IOException { - drawBuffer(0); - } - - /** - * Clear ahead the specified number of characters without moving the cursor. - * - * @param num the number of characters to clear - * @param delta the difference between the internal cursor and the screen - * cursor - if > 0, assume some stuff was printed and weird wrap has to be - * checked - */ - private void clearAhead(final int num, int delta) throws IOException { - if (num == 0) { - return; - } - - if (getTerminal().isAnsiSupported()) { - int width = getTerminal().getWidth(); - int screenCursorCol = getCursorPosition() + delta; - // clear current line - printAnsiSequence("K"); - // if cursor+num wraps, then we need to clear the line(s) below too - int curCol = screenCursorCol % width; - int endCol = (screenCursorCol + num - 1) % width; - int lines = num / width; - if (endCol < curCol) lines++; - for (int i = 0; i < lines; i++) { - printAnsiSequence("B"); - printAnsiSequence("2K"); - } - for (int i = 0; i < lines; i++) { - printAnsiSequence("A"); - } - return; - } - - // print blank extra characters - print(' ', num); - - // we need to flush here so a "clever" console doesn't just ignore the redundancy - // of a space followed by a backspace. -// flush(); - - // reset the visual cursor - back(num); - -// flush(); - } - - /** - * Move the visual cursor backwards without modifying the buffer cursor. - */ - protected void back(final int num) throws IOException { - if (num == 0) return; - if (getTerminal().isAnsiSupported()) { - int width = getTerminal().getWidth(); - int cursor = getCursorPosition(); - int realCursor = cursor + num; - int realCol = realCursor % width; - int newCol = cursor % width; - int moveup = num / width; - int delta = realCol - newCol; - if (delta < 0) moveup++; - if (moveup > 0) { - printAnsiSequence(moveup + "A"); - } - printAnsiSequence((1 + newCol) + "G"); - return; - } - print(BACKSPACE, num); -// flush(); - } - - /** - * Flush the console output stream. This is important for printout out single characters (like a backspace or - * keyboard) that we want the console to handle immediately. - */ - public void flush() throws IOException { - out.flush(); - } - - private int backspaceAll() throws IOException { - return backspace(Integer.MAX_VALUE); - } - - /** - * Issue num backspaces. - * - * @return the number of characters backed up - */ - private int backspace(final int num) throws IOException { - if (buf.cursor == 0) { - return 0; - } - - int count = 0; - - int termwidth = getTerminal().getWidth(); - int lines = getCursorPosition() / termwidth; - count = moveCursor(-1 * num) * -1; - buf.buffer.delete(buf.cursor, buf.cursor + count); - if (getCursorPosition() / termwidth != lines) { - if (getTerminal().isAnsiSupported()) { - // debug("doing backspace redraw: " + getCursorPosition() + " on " + termwidth + ": " + lines); - printAnsiSequence("K"); - // if cursor+num wraps, then we need to clear the line(s) below too - // last char printed is one pos less than cursor so we subtract - // one -/* - // TODO: fixme (does not work - test with reverse search with wrapping line and CTRL-E) - int endCol = (getCursorPosition() + num - 1) % termwidth; - int curCol = getCursorPosition() % termwidth; - if (endCol < curCol) lines++; - for (int i = 1; i < lines; i++) { - printAnsiSequence("B"); - printAnsiSequence("2K"); - } - for (int i = 1; i < lines; i++) { - printAnsiSequence("A"); - } - return count; -*/ - } - } - drawBuffer(count); - - return count; - } - - /** - * Issue a backspace. - * - * @return true if successful - */ - public boolean backspace() throws IOException { - return backspace(1) == 1; - } - - protected boolean moveToEnd() throws IOException { - return moveCursor(buf.length() - buf.cursor) > 0; - } - - /** - * Delete the character at the current position and redraw the remainder of the buffer. - */ - private boolean deleteCurrentCharacter() throws IOException { - if (buf.length() == 0 || buf.cursor == buf.length()) { - return false; - } - - buf.buffer.deleteCharAt(buf.cursor); - drawBuffer(1); - return true; - } - - private boolean previousWord() throws IOException { - while (isDelimiter(buf.charLeftOfCursor()) && (moveCursor(-1) != 0)) { - // nothing - } - - while (!isDelimiter(buf.charLeftOfCursor()) && (moveCursor(-1) != 0)) { - // nothing - } - - return true; - } - - private boolean nextWord() throws IOException { - while (isDelimiter(buf.charAtCursor()) && (moveCursor(1) != 0)) { - // nothing - } - - while (!isDelimiter(buf.charAtCursor()) && (moveCursor(1) != 0)) { - // nothing - } - - return true; - } - - private boolean deletePreviousWord() throws IOException { - while (isDelimiter(buf.charLeftOfCursor()) && backspace()) { - // nothing - } - - while (!isDelimiter(buf.charLeftOfCursor()) && backspace()) { - // nothing - } - - return true; - } - - private boolean deleteNextWord() throws IOException { - while (isDelimiter(buf.charAtCursor()) && deleteCurrentCharacter()) { - // nothing - } - - while (!isDelimiter(buf.charAtCursor()) && deleteCurrentCharacter()) { - // nothing - } - - return true; - } - - /** - * Move the cursor where characters. - * - * @param num If less than 0, move abs(where) to the left, otherwise move where to the right. - * @return The number of spaces we moved - */ - public int moveCursor(final int num) throws IOException { - int where = num; - - if ((buf.cursor == 0) && (where <= 0)) { - return 0; - } - - if ((buf.cursor == buf.buffer.length()) && (where >= 0)) { - return 0; - } - - if ((buf.cursor + where) < 0) { - where = -buf.cursor; - } - else if ((buf.cursor + where) > buf.buffer.length()) { - where = buf.buffer.length() - buf.cursor; - } - - moveInternal(where); - - return where; - } - - /** - * Move the cursor where characters, without checking the current buffer. - * - * @param where the number of characters to move to the right or left. - */ - private void moveInternal(final int where) throws IOException { - // debug ("move cursor " + where + " (" - // + buf.cursor + " => " + (buf.cursor + where) + ")"); - buf.cursor += where; - - if (getTerminal().isAnsiSupported()) { - if (where < 0) { - back(Math.abs(where)); - } else { - int width = getTerminal().getWidth(); - int cursor = getCursorPosition(); - int oldLine = (cursor - where) / width; - int newLine = cursor / width; - if (newLine > oldLine) { - if (getTerminal().hasWeirdWrap()) { - // scroll up if at bottom - // note: - // on rxvt cywgin getTerminal().getHeight() is incorrect - // MacOs xterm does not seem to support scrolling - if (getCurrentAnsiRow() == getTerminal().getHeight()) { - printAnsiSequence((newLine - oldLine) + "S"); - } - } - printAnsiSequence((newLine - oldLine) + "B"); - } - printAnsiSequence(1 +(cursor % width) + "G"); - } -// flush(); - return; - } - - char c; - - if (where < 0) { - int len = 0; - for (int i = buf.cursor; i < buf.cursor - where; i++) { - if (buf.buffer.charAt(i) == '\t') { - len += TAB_WIDTH; - } - else { - len++; - } - } - - char chars[] = new char[len]; - Arrays.fill(chars, BACKSPACE); - out.write(chars); - - return; - } - else if (buf.cursor == 0) { - return; - } - else if (mask != null) { - c = mask; - } - else { - print(buf.buffer.substring(buf.cursor - where, buf.cursor).toCharArray()); - return; - } - - // null character mask: don't output anything - if (mask == NULL_MASK) { - return; - } - - print(c, Math.abs(where)); - } - - // FIXME: replace() is not used - - public final boolean replace(final int num, final String replacement) { - buf.buffer.replace(buf.cursor - num, buf.cursor, replacement); - try { - moveCursor(-num); - drawBuffer(Math.max(0, num - replacement.length())); - moveCursor(replacement.length()); - } - catch (IOException e) { - e.printStackTrace(); - return false; - } - return true; - } - - // - // Key reading - // - - /** - * Read a character from the console. - * - * @return the character, or -1 if an EOF is received. - */ - public final int readVirtualKey() throws IOException { - int c = getTerminal().readVirtualKey(in); - - Log.trace("Keystroke: ", c); - - // clear any echo characters - clearEcho(c); - - return c; - } - - /** - * Clear the echoed characters for the specified character code. - */ - private int clearEcho(final int c) throws IOException { - // if the terminal is not echoing, then ignore - if (!getTerminal().isEchoEnabled()) { - return 0; - } - - // otherwise, clear - int num = countEchoCharacters((char) c); - back(num); - drawBuffer(num); - - return num; - } - - private int countEchoCharacters(final char c) { - // tabs as special: we need to determine the number of spaces - // to cancel based on what out current cursor position is - if (c == 9) { - int tabStop = 8; // will this ever be different? - int position = getCursorPosition(); - - return tabStop - (position % tabStop); - } - - return getPrintableCharacters(c).length(); - } - - /** - * Return the number of characters that will be printed when the specified - * character is echoed to the screen - * - * Adapted from cat by Torbjorn Granlund, as repeated in stty by David MacKenzie. - */ - private StringBuilder getPrintableCharacters(final char ch) { - StringBuilder sbuff = new StringBuilder(); - - if (ch >= 32) { - if (ch < 127) { - sbuff.append(ch); - } - else if (ch == 127) { - sbuff.append('^'); - sbuff.append('?'); - } - else { - sbuff.append('M'); - sbuff.append('-'); - - if (ch >= (128 + 32)) { - if (ch < (128 + 127)) { - sbuff.append((char) (ch - 128)); - } - else { - sbuff.append('^'); - sbuff.append('?'); - } - } - else { - sbuff.append('^'); - sbuff.append((char) (ch - 128 + 64)); - } - } - } - else { - sbuff.append('^'); - sbuff.append((char) (ch + 64)); - } - - return sbuff; - } - - public final int readCharacter(final char... allowed) throws IOException { - // if we restrict to a limited set and the current character is not in the set, then try again. - char c; - - Arrays.sort(allowed); // always need to sort before binarySearch - - while (Arrays.binarySearch(allowed, c = (char) readVirtualKey()) < 0) { - // nothing - } - - return c; - } - - // - // Key Bindings - // - - public static final String JLINE_COMPLETION_THRESHOLD = "jline.completion.threshold"; - - public static final String JLINE_KEYBINDINGS = "jline.keybindings"; - - public static final String JLINEBINDINGS_PROPERTIES = ".jlinebindings.properties"; - - /** - * The map for logical operations. - */ - private final short[] keyBindings; - - private short[] loadKeyBindings(InputStream input) throws IOException { - if (input == null) { - try { - File file = new File(Configuration.getUserHome(), JLINEBINDINGS_PROPERTIES); - - String path = Configuration.getString(JLINE_KEYBINDINGS); - if (path != null) { - file = new File(path); - } - - if (file.isFile()) { - Log.debug("Loading user bindings from: ", file); - input = new FileInputStream(file); - } - } - catch (Exception e) { - Log.error("Failed to load user bindings", e); - } - } - - if (input == null) { - Log.debug("Using default bindings"); - input = getTerminal().getDefaultBindings(); - } - - short[] keyBindings = new short[Character.MAX_VALUE * 2]; - - Arrays.fill(keyBindings, Operation.UNKNOWN.code); - - // Loads the key bindings. Bindings file is in the format: - // - // keycode: operation name - - if (input != null) { - input = new BufferedInputStream(input); - Properties p = new Properties(); - p.load(input); - input.close(); - - for (Object key : p.keySet()) { - String val = (String) key; - - try { - short code = Short.parseShort(val); - String name = p.getProperty(val); - Operation op = Operation.valueOf(name); - keyBindings[code] = op.code; - } - catch (NumberFormatException e) { - Log.error("Failed to convert binding code: ", val, e); - } - } - - // hardwired arrow key bindings - // keybindings[VK_UP] = PREV_HISTORY; - // keybindings[VK_DOWN] = NEXT_HISTORY; - // keybindings[VK_LEFT] = PREV_CHAR; - // keybindings[VK_RIGHT] = NEXT_CHAR; - } - - return keyBindings; - } - - int getKeyForAction(final short logicalAction) { - for (int i = 0; i < keyBindings.length; i++) { - if (keyBindings[i] == logicalAction) { - return i; - } - } - - return -1; - } - - int getKeyForAction(final Operation op) { - assert op != null; - return getKeyForAction(op.code); - } - - public void printBindings() { - System.out.println("printBindings(): keyBindings.length = " + keyBindings.length); - for (int i = 0; i < keyBindings.length; i++) { - if (keyBindings[i] != Operation.UNKNOWN.code) { - System.out.println("keyBindings[" + i + "] = " + keyBindings[i]); - } - } - } - - /** - * Reads the console input and returns an array of the form [raw, key binding]. - */ - private int[] readBinding() throws IOException { - int c = readVirtualKey(); - - if (c == -1) { - return null; - } - - // extract the appropriate key binding - short code = keyBindings[c]; - - Log.trace("Translated: ", c, " -> ", code); - - return new int[]{c, code}; - } - - // - // Line Reading - // - - /** - * Read the next line and return the contents of the buffer. - */ - public String readLine() throws IOException { - return readLine((String) null); - } - - /** - * Read the next line with the specified character mask. If null, then - * characters will be echoed. If 0, then no characters will be echoed. - */ - public String readLine(final Character mask) throws IOException { - return readLine(null, mask); - } - - public String readLine(final String prompt) throws IOException { - return readLine(prompt, null); - } - - /** - * Read a line from the in {@link InputStream}, and return the line - * (without any trailing newlines). - * - * @param prompt The prompt to issue to the console, may be null. - * @return A line that is read from the terminal, or null if there was null input (e.g., CTRL-D - * was pressed). - */ - public String readLine(String prompt, final Character mask) throws IOException { - // prompt may be null - // mask may be null - - // FIXME: This blows, each call to readLine will reset the console's state which doesn't seem very nice. - this.mask = mask; - if (prompt != null) { - setPrompt(prompt); - } - else { - prompt = getPrompt(); - } - - try { - if (!getTerminal().isSupported()) { - beforeReadLine(prompt, mask); - } - - if (prompt != null && prompt.length() > 0) { - out.write(prompt); - out.flush(); - } - - // if the terminal is unsupported, just use plain-java reading - if (!getTerminal().isSupported()) { - return readLine(in); - } - - String originalPrompt = this.prompt; - - final int NORMAL = 1; - final int SEARCH = 2; - int state = NORMAL; - - boolean success = true; - - while (true) { - int[] next = readBinding(); - - if (next == null) { - return null; - } - - int c = next[0]; - // int code = next[1]; - Operation code = Operation.valueOf(next[1]); - - if (c == -1) { - return null; - } - - // Search mode. - // - // Note that we have to do this first, because if there is a command - // not linked to a search command, we leave the search mode and fall - // through to the normal state. - if (state == SEARCH) { - int cursorDest = -1; - - switch (code) { - // This doesn't work right now, it seems CTRL-G is not passed - // down correctly. :( - case ABORT: - state = NORMAL; - break; - - case SEARCH_PREV: - if (searchTerm.length() == 0) { - searchTerm.append(previousSearchTerm); - } - - if (searchIndex == -1) { - searchIndex = searchBackwards(searchTerm.toString()); - } else { - searchIndex = searchBackwards(searchTerm.toString(), searchIndex); - } - break; - - case DELETE_PREV_CHAR: - if (searchTerm.length() > 0) { - searchTerm.deleteCharAt(searchTerm.length() - 1); - searchIndex = searchBackwards(searchTerm.toString()); - } - break; - - case UNKNOWN: - searchTerm.appendCodePoint(c); - searchIndex = searchBackwards(searchTerm.toString()); - break; - - default: - // Set buffer and cursor position to the found string. - if (searchIndex != -1) { - history.moveTo(searchIndex); - // set cursor position to the found string - cursorDest = history.current().toString().indexOf(searchTerm.toString()); - } - state = NORMAL; - break; - } - - // if we're still in search mode, print the search status - if (state == SEARCH) { - if (searchTerm.length() == 0) { - printSearchStatus("", ""); - searchIndex = -1; - } else { - if (searchIndex == -1) { - beep(); - } else { - printSearchStatus(searchTerm.toString(), history.get(searchIndex).toString()); - } - } - } - // otherwise, restore the line - else { - restoreLine(originalPrompt, cursorDest); - } - } - - if (state == NORMAL) { - switch (code) { - case EXIT: // ctrl-d - if (buf.buffer.length() == 0) { - return null; - } else { - success = deleteCurrentCharacter(); - } - break; - - case COMPLETE: // tab - success = complete(); - break; - - case MOVE_TO_BEG: - success = setCursorPosition(0); - break; - - case KILL_LINE: // CTRL-K - success = killLine(); - break; - - case CLEAR_SCREEN: // CTRL-L - success = clearScreen(); - break; - - case KILL_LINE_PREV: // CTRL-U - success = resetLine(); - break; - - case NEWLINE: // enter - moveToEnd(); - println(); // output newline - flush(); - return finishBuffer(); - - case DELETE_PREV_CHAR: // backspace - success = backspace(); - break; - - case DELETE_NEXT_CHAR: // delete - success = deleteCurrentCharacter(); - break; - - case MOVE_TO_END: - success = moveToEnd(); - break; - - case PREV_CHAR: - success = moveCursor(-1) != 0; - break; - - case NEXT_CHAR: - success = moveCursor(1) != 0; - break; - - case NEXT_HISTORY: - success = moveHistory(true); - break; - - case PREV_HISTORY: - success = moveHistory(false); - break; - - case ABORT: - case REDISPLAY: - break; - - case PASTE: - success = paste(); - break; - - case DELETE_PREV_WORD: - success = deletePreviousWord(); - break; - - case DELETE_NEXT_WORD: - success = deleteNextWord(); - break; - - case PREV_WORD: - success = previousWord(); - break; - - case NEXT_WORD: - success = nextWord(); - break; - - case START_OF_HISTORY: - success = history.moveToFirst(); - if (success) { - setBuffer(history.current()); - } - break; - - case END_OF_HISTORY: - success = history.moveToLast(); - if (success) { - setBuffer(history.current()); - } - break; - - case CLEAR_LINE: - moveInternal(-(buf.cursor)); - killLine(); - break; - - case INSERT: - buf.setOverTyping(!buf.isOverTyping()); - break; - - case SEARCH_PREV: // CTRL-R - if (searchTerm != null) { - previousSearchTerm = searchTerm.toString(); - } - searchTerm = new StringBuffer(buf.buffer); - state = SEARCH; - if (searchTerm.length() > 0) { - searchIndex = searchBackwards(searchTerm.toString()); - if (searchIndex == -1) { - beep(); - } - printSearchStatus(searchTerm.toString(), - searchIndex > -1 ? history.get(searchIndex).toString() : ""); - } else { - searchIndex = -1; - printSearchStatus("", ""); - } - break; - - case UNKNOWN: - default: - if (c != 0) { // ignore null chars - ActionListener action = triggeredActions.get((char) c); - if (action != null) { - action.actionPerformed(null); - } - else { - putChar(c, true); - } - } - else { - success = false; - } - } - - if (!success) { - beep(); - } - - flush(); - } - } - } - finally { - if (!getTerminal().isSupported()) { - afterReadLine(); - } - } - } - - /** - * Read a line for unsupported terminals. - */ - private String readLine(final InputStream in) throws IOException { - StringBuilder buff = new StringBuilder(); - - while (true) { - int i = in.read(); - - if (i == -1 || i == '\n' || i == '\r') { - return buff.toString(); - } - - buff.append((char) i); - } - - // return new BufferedReader (new InputStreamReader (in)).readLine (); - } - - // - // Completion - // - - private final List completers = new LinkedList(); - - private CompletionHandler completionHandler = new CandidateListCompletionHandler(); - - /** - * Add the specified {@link jline.console.completer.Completer} to the list of handlers for tab-completion. - * - * @param completer the {@link jline.console.completer.Completer} to add - * @return true if it was successfully added - */ - public boolean addCompleter(final Completer completer) { - return completers.add(completer); - } - - /** - * Remove the specified {@link jline.console.completer.Completer} from the list of handlers for tab-completion. - * - * @param completer The {@link Completer} to remove - * @return True if it was successfully removed - */ - public boolean removeCompleter(final Completer completer) { - return completers.remove(completer); - } - - /** - * Returns an unmodifiable list of all the completers. - */ - public Collection getCompleters() { - return Collections.unmodifiableList(completers); - } - - public void setCompletionHandler(final CompletionHandler handler) { - assert handler != null; - this.completionHandler = handler; - } - - public CompletionHandler getCompletionHandler() { - return this.completionHandler; - } - - /** - * Use the completers to modify the buffer with the appropriate completions. - * - * @return true if successful - */ - protected boolean complete() throws IOException { - // debug ("tab for (" + buf + ")"); - if (completers.size() == 0) { - return false; - } - - List candidates = new LinkedList(); - String bufstr = buf.buffer.toString(); - int cursor = buf.cursor; - - int position = -1; - - for (Completer comp : completers) { - if ((position = comp.complete(bufstr, cursor, candidates)) != -1) { - break; - } - } - - return candidates.size() != 0 && getCompletionHandler().complete(this, candidates, position); - } - - /** - * The number of tab-completion candidates above which a warning will be - * prompted before showing all the candidates. - */ - private int autoprintThreshold = Integer.getInteger(JLINE_COMPLETION_THRESHOLD, 100); // same default as bash - - /** - * @param threshold the number of candidates to print without issuing a warning. - */ - public void setAutoprintThreshold(final int threshold) { - this.autoprintThreshold = threshold; - } - - /** - * @return the number of candidates to print without issuing a warning. - */ - public int getAutoprintThreshold() { - return autoprintThreshold; - } - - private boolean paginationEnabled; - - /** - * Whether to use pagination when the number of rows of candidates exceeds the height of the terminal. - */ - public void setPaginationEnabled(final boolean enabled) { - this.paginationEnabled = enabled; - } - - /** - * Whether to use pagination when the number of rows of candidates exceeds the height of the terminal. - */ - public boolean isPaginationEnabled() { - return paginationEnabled; - } - - // - // History - // - - private History history = new MemoryHistory(); - - public void setHistory(final History history) { - this.history = history; - } - - public History getHistory() { - return history; - } - - private boolean historyEnabled = true; - - /** - * Whether or not to add new commands to the history buffer. - */ - public void setHistoryEnabled(final boolean enabled) { - this.historyEnabled = enabled; - } - - /** - * Whether or not to add new commands to the history buffer. - */ - public boolean isHistoryEnabled() { - return historyEnabled; - } - - /** - * Move up or down the history tree. - */ - private boolean moveHistory(final boolean next) throws IOException { - if (next && !history.next()) { - return false; - } - else if (!next && !history.previous()) { - return false; - } - - setBuffer(history.current()); - - return true; - } - - // - // Printing - // - - public static final String CR = System.getProperty("line.separator"); - - /** - * Output the specified character to the output stream without manipulating the current buffer. - */ - private void print(final int c) throws IOException { - if (c == '\t') { - char chars[] = new char[TAB_WIDTH]; - Arrays.fill(chars, ' '); - out.write(chars); - return; - } - - out.write(c); - } - - /** - * Output the specified characters to the output stream without manipulating the current buffer. - */ - private void print(final char... buff) throws IOException { - int len = 0; - for (char c : buff) { - if (c == '\t') { - len += TAB_WIDTH; - } - else { - len++; - } - } - - char chars[]; - if (len == buff.length) { - chars = buff; - } - else { - chars = new char[len]; - int pos = 0; - for (char c : buff) { - if (c == '\t') { - Arrays.fill(chars, pos, pos + TAB_WIDTH, ' '); - pos += TAB_WIDTH; - } - else { - chars[pos] = c; - pos++; - } - } - } - - out.write(chars); - } - - private void print(final char c, final int num) throws IOException { - if (num == 1) { - print(c); - } - else { - char[] chars = new char[num]; - Arrays.fill(chars, c); - print(chars); - } - } - - /** - * Output the specified string to the output stream (but not the buffer). - */ - public final void print(final CharSequence s) throws IOException { - assert s != null; - print(s.toString().toCharArray()); - } - - public final void println(final CharSequence s) throws IOException { - assert s != null; - print(s.toString().toCharArray()); - println(); - } - - /** - * Output a platform-dependent newline. - */ - public final void println() throws IOException { - print(CR); -// flush(); - } - - // - // Actions - // - - /** - * Issue a delete. - * - * @return true if successful - */ - public final boolean delete() throws IOException { - return delete(1) == 1; - } - - // FIXME: delete(int) only used by above + the return is always 1 and num is ignored - - /** - * Issue num deletes. - * - * @return the number of characters backed up - */ - private int delete(final int num) throws IOException { - // TODO: Try to use jansi for this - - /* Commented out because of DWA-2949: - if (buf.cursor == 0) { - return 0; - } - */ - - buf.buffer.delete(buf.cursor, buf.cursor + 1); - drawBuffer(1); - - return 1; - } - - /** - * Kill the buffer ahead of the current cursor position. - * - * @return true if successful - */ - public boolean killLine() throws IOException { - int cp = buf.cursor; - int len = buf.buffer.length(); - - if (cp >= len) { - return false; - } - - int num = buf.buffer.length() - cp; - clearAhead(num, 0); - - for (int i = 0; i < num; i++) { - buf.buffer.deleteCharAt(len - i - 1); - } - - return true; - } - - /** - * Clear the screen by issuing the ANSI "clear screen" code. - */ - public boolean clearScreen() throws IOException { - if (!getTerminal().isAnsiSupported()) { - return false; - } - - // send the ANSI code to clear the screen - printAnsiSequence("2J"); - - // then send the ANSI code to go to position 1,1 - printAnsiSequence("1;1H"); - - redrawLine(); - - return true; - } - - /** - * Issue an audible keyboard bell, if {@link #isBellEnabled} return true. - */ - public void beep() throws IOException { - if (isBellEnabled()) { - print(KEYBOARD_BELL); - // need to flush so the console actually beeps - flush(); - } - } - - /** - * Paste the contents of the clipboard into the console buffer - * - * @return true if clipboard contents pasted - */ - public boolean paste() throws IOException { - Clipboard clipboard; - try { // May throw ugly exception on system without X - clipboard = Toolkit.getDefaultToolkit().getSystemClipboard(); - } - catch (Exception e) { - return false; - } - - if (clipboard == null) { - return false; - } - - Transferable transferable = clipboard.getContents(null); - - if (transferable == null) { - return false; - } - - try { - Object content = transferable.getTransferData(DataFlavor.plainTextFlavor); - - // This fix was suggested in bug #1060649 at - // http://sourceforge.net/tracker/index.php?func=detail&aid=1060649&group_id=64033&atid=506056 - // to get around the deprecated DataFlavor.plainTextFlavor, but it - // raises a UnsupportedFlavorException on Mac OS X - - if (content == null) { - try { - content = new DataFlavor().getReaderForText(transferable); - } - catch (Exception e) { - // ignore - } - } - - if (content == null) { - return false; - } - - String value; - - if (content instanceof Reader) { - // TODO: we might want instead connect to the input stream - // so we can interpret individual lines - value = ""; - String line; - - BufferedReader read = new BufferedReader((Reader) content); - while ((line = read.readLine()) != null) { - if (value.length() > 0) { - value += "\n"; - } - - value += line; - } - } - else { - value = content.toString(); - } - - if (value == null) { - return true; - } - - putString(value); - - return true; - } - catch (UnsupportedFlavorException e) { - Log.error("Paste failed: ", e); - - return false; - } - } - - // - // Triggered Actions - // - - private final Map triggeredActions = new HashMap(); - - /** - * Adding a triggered Action allows to give another curse of action if a character passed the pre-processing. - *

    - * Say you want to close the application if the user enter q. - * addTriggerAction('q', new ActionListener(){ System.exit(0); }); would do the trick. - */ - public void addTriggeredAction(final char c, final ActionListener listener) { - triggeredActions.put(c, listener); - } - - // - // Formatted Output - // - - /** - * Output the specified {@link Collection} in proper columns. - */ - public void printColumns(final Collection items) throws IOException { - if (items == null || items.isEmpty()) { - return; - } - - int width = getTerminal().getWidth(); - int height = getTerminal().getHeight(); - - int maxWidth = 0; - for (CharSequence item : items) { - maxWidth = Math.max(maxWidth, item.length()); - } - Log.debug("Max width: ", maxWidth); - - int showLines; - if (isPaginationEnabled()) { - showLines = height - 1; // page limit - } - else { - showLines = Integer.MAX_VALUE; - } - - StringBuilder buff = new StringBuilder(); - for (CharSequence item : items) { - if ((buff.length() + maxWidth) > width) { - println(buff); - buff.setLength(0); - - if (--showLines == 0) { - // Overflow - print(resources.getString("display-more")); - flush(); - int c = readVirtualKey(); - if (c == '\r' || c == '\n') { - // one step forward - showLines = 1; - } - else if (c != 'q') { - // page forward - showLines = height - 1; - } - - back(resources.getString("display-more").length()); - if (c == 'q') { - // cancel - break; - } - } - } - - // NOTE: toString() is important here due to AnsiString being retarded - buff.append(item.toString()); - for (int i = 0; i < (maxWidth + 3 - item.length()); i++) { - buff.append(' '); - } - } - - if (buff.length() > 0) { - println(buff); - } - } - - // - // Non-supported Terminal Support - // - - private Thread maskThread; - - private void beforeReadLine(final String prompt, final Character mask) { - if (mask != null && maskThread == null) { - final String fullPrompt = "\r" + prompt - + " " - + " " - + " " - + "\r" + prompt; - - maskThread = new Thread() - { - public void run() { - while (!interrupted()) { - try { - Writer out = getOutput(); - out.write(fullPrompt); - out.flush(); - sleep(3); - } - catch (IOException e) { - return; - } - catch (InterruptedException e) { - return; - } - } - } - }; - - maskThread.setPriority(Thread.MAX_PRIORITY); - maskThread.setDaemon(true); - maskThread.start(); - } - } - - private void afterReadLine() { - if (maskThread != null && maskThread.isAlive()) { - maskThread.interrupt(); - } - - maskThread = null; - } - - /** - * Erases the current line with the existing prompt, then redraws the line - * with the provided prompt and buffer - * @param prompt - * the new prompt - * @param buffer - * the buffer to be drawn - * @param cursorDest - * where you want the cursor set when the line has been drawn. - * -1 for end of line. - * */ - public void resetPromptLine(String prompt, String buffer, int cursorDest) throws IOException { - // move cursor to end of line - moveToEnd(); - - // backspace all text, including prompt - buf.buffer.append(this.prompt); - buf.cursor += this.prompt.length(); - this.prompt = ""; - backspaceAll(); - - this.prompt = prompt; - redrawLine(); - setBuffer(buffer); - - // move cursor to destination (-1 will move to end of line) - if (cursorDest < 0) cursorDest = buffer.length(); - setCursorPosition(cursorDest); - - flush(); - } - - public void printSearchStatus(String searchTerm, String match) throws IOException { - String prompt = "(reverse-i-search)`" + searchTerm + "': "; - String buffer = match; - int cursorDest = match.indexOf(searchTerm); - resetPromptLine(prompt, buffer, cursorDest); - } - - public void restoreLine(String originalPrompt, int cursorDest) throws IOException { - // TODO move cursor to matched string - String prompt = lastLine(originalPrompt); - String buffer = buf.buffer.toString(); - resetPromptLine(prompt, buffer, cursorDest); - } - - // - // History search - // - /** - * Search backward in history from a given position. - * - * @param searchTerm substring to search for. - * @param startIndex the index from which on to search - * @return index where this substring has been found, or -1 else. - */ - public int searchBackwards(String searchTerm, int startIndex) { - return searchBackwards(searchTerm, startIndex, false); - } - - /** - * Search backwards in history from the current position. - * - * @param searchTerm substring to search for. - * @return index where the substring has been found, or -1 else. - */ - public int searchBackwards(String searchTerm) { - return searchBackwards(searchTerm, history.index()); - } - - - public int searchBackwards(String searchTerm, int startIndex, boolean startsWith) { - ListIterator it = history.entries(startIndex); - while (it.hasPrevious()) { - History.Entry e = it.previous(); - if (startsWith) { - if (e.value().toString().startsWith(searchTerm)) { - return e.index(); - } - } else { - if (e.value().toString().contains(searchTerm)) { - return e.index(); - } - } - } - return -1; - } - - // - // Helpers - // - - /** - * Checks to see if the specified character is a delimiter. We consider a - * character a delimiter if it is anything but a letter or digit. - * - * @param c The character to test - * @return True if it is a delimiter - */ - private boolean isDelimiter(final char c) { - return !Character.isLetterOrDigit(c); - } - - private void printAnsiSequence(String sequence) throws IOException { - print(27); - print('['); - print(sequence); - flush(); // helps with step debugging - } - - // return column position, reported by the terminal - private int getCurrentPosition() { - // check for ByteArrayInputStream to disable for unit tests - if (getTerminal().isAnsiSupported() && !(in instanceof ByteArrayInputStream)) { - try { - printAnsiSequence("6n"); - flush(); - StringBuffer b = new StringBuffer(8); - // position is sent as [{ROW};{COLUMN}R - int r; - while((r = in.read()) > -1 && r != 'R') { - if (r != 27 && r != '[') { - b.append((char) r); - } - } - String[] pos = b.toString().split(";"); - return Integer.parseInt(pos[1]); - } catch (Exception x) { - // no luck - } - } - - return -1; // TODO: throw exception instead? - } - - // return row position, reported by the terminal - // needed to know whether to scroll up on cursor move in last col for weird - // wrapping terminals - not tested for anything else - private int getCurrentAnsiRow() { - // check for ByteArrayInputStream to disable for unit tests - if (getTerminal().isAnsiSupported() && !(in instanceof ByteArrayInputStream)) { - try { - printAnsiSequence("6n"); - flush(); - StringBuffer b = new StringBuffer(8); - // position is sent as [{ROW};{COLUMN}R - int r; - while((r = in.read()) > -1 && r != 'R') { - if (r != 27 && r != '[') { - b.append((char) r); - } - } - String[] pos = b.toString().split(";"); - return Integer.parseInt(pos[0]); - } catch (Exception x) { - // no luck - } - } - - return -1; // TODO: throw exception instead? - } -} diff --git a/src/jline/src/main/java/scala/tools/jline/console/CursorBuffer.java b/src/jline/src/main/java/scala/tools/jline/console/CursorBuffer.java deleted file mode 100644 index 7993def00210..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/CursorBuffer.java +++ /dev/null @@ -1,106 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline.console; - -/** - * A holder for a {@link StringBuilder} that also contains the current cursor position. - * - * @author Marc Prud'hommeaux - * @author Jason Dillon - * @since 2.0 - */ -public class CursorBuffer -{ - private boolean overTyping = false; - - public int cursor = 0; - - public final StringBuilder buffer = new StringBuilder(); - - public boolean isOverTyping() { - return overTyping; - } - - public void setOverTyping(final boolean b) { - overTyping = b; - } - - public int length() { - return buffer.length(); - } - - /** - * Gets the character to the left of the cursor. - */ - public char charLeftOfCursor() { - if (cursor <= 0) { - return 0; - } - - return buffer.charAt(cursor - 1); - } - - /** - * Gets the character at the cursor. - */ - public char charAtCursor() { - if (cursor < 0 || cursor >= buffer.length()) { - return 0; - } - return buffer.charAt(cursor); - } - - /** - * Write the specific character into the buffer, setting the cursor position - * ahead one. The text may overwrite or insert based on the current setting - * of {@link #isOverTyping}. - * - * @param c the character to insert - */ - public void write(final char c) { - buffer.insert(cursor++, c); - if (isOverTyping() && cursor < buffer.length()) { - buffer.deleteCharAt(cursor); - } - } - - /** - * Insert the specified chars into the buffer, setting the cursor to the end of the insertion point. - */ - public void write(final CharSequence str) { - assert str != null; - - if (buffer.length() == 0) { - buffer.append(str); - } - else { - buffer.insert(cursor, str); - } - - cursor += str.length(); - - if (isOverTyping() && cursor < buffer.length()) { - buffer.delete(cursor, (cursor + str.length())); - } - } - - public boolean clear() { - if (buffer.length() == 0) { - return false; - } - - buffer.delete(0, buffer.length()); - cursor = 0; - return true; - } - - @Override - public String toString() { - return buffer.toString(); - } -} diff --git a/src/jline/src/main/java/scala/tools/jline/console/Key.java b/src/jline/src/main/java/scala/tools/jline/console/Key.java deleted file mode 100644 index 2e713a7da2c6..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/Key.java +++ /dev/null @@ -1,82 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline.console; - -import java.util.HashMap; -import java.util.Map; - -/** - * Map from key name to key codes. - * - * @author Marc Prud'hommeaux - * @author Jason Dillon - * @see java.awt.event.KeyEvent - * @since 2.0 - */ -public enum Key -{ - CTRL_A(1), - - CTRL_B(2), - - CTRL_C(3), - - CTRL_D(4), - - CTRL_E(5), - - CTRL_F(6), - - CTRL_G(7), - - CTRL_K(11), - - CTRL_L(12), - - CTRL_N(14), - - CTRL_O(15), - - CTRL_P(16), - - CTRL_T(20), - - CTRL_W(23), - - CTRL_X(24), - - CTRL_OB(27), - - CTRL_QM(127), - - BACKSPACE('\b'), - - DELETE(127),; - - public final short code; - - Key(final int code) { - this.code = (short) code; - } - - private static final Map codes; - - static { - Map map = new HashMap(); - - for (Key op : Key.values()) { - map.put(op.code, op); - } - - codes = map; - } - - public static Key valueOf(final int code) { - return codes.get((short) code); - } -} \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/console/Operation.java b/src/jline/src/main/java/scala/tools/jline/console/Operation.java deleted file mode 100644 index 59ee878d4544..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/Operation.java +++ /dev/null @@ -1,291 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline.console; - -import java.util.HashMap; -import java.util.Map; - -/** - * Map for console operation to virtual key bindings. - * - * @author Marc Prud'hommeaux - * @author Jason Dillon - * @see java.awt.event.KeyEvent - * @since 2.0 - */ -public enum Operation -{ - /** - * Unknown operation. - */ - UNKNOWN(-99), - - /** - * Operation that moves to the beginning of the buffer. - */ - MOVE_TO_BEG(-1), - - /** - * Operation that moves to the end of the buffer. - */ - MOVE_TO_END(-3), - - /** - * Operation that moved to the previous character in the buffer. - */ - PREV_CHAR(-4), - - /** - * Operation that issues a newline. - */ - NEWLINE(-6), - - /** - * Operation that deletes the buffer from the current character to the end. - */ - KILL_LINE(-7), - - /** - * Operation that clears the screen. - */ - CLEAR_SCREEN(-8), - - /** - * Operation that sets the buffer to the next history item. - */ - NEXT_HISTORY(-9), - - /** - * Operation that sets the buffer to the previous history item. - */ - PREV_HISTORY(-11), - - /** - * Operation that redisplays the current buffer. - */ - REDISPLAY(-13), - - /** - * Operation that deletes the buffer from the cursor to the beginning. - */ - KILL_LINE_PREV(-15), - - /** - * Operation that deletes the previous word in the buffer. - */ - DELETE_PREV_WORD(-16), - - /** - * Operation that moves to the next character in the buffer. - */ - NEXT_CHAR(-19), - - /** - * Operation that moves to the previous character in the buffer. - */ - REPEAT_PREV_CHAR(-20), - - /** - * Operation that searches backwards in the command history. - */ - SEARCH_PREV(-21), - - /** - * Operation that repeats the character. - */ - REPEAT_NEXT_CHAR(-24), - - /** - * Operation that searches forward in the command history. - */ - SEARCH_NEXT(-25), - - /** - * Operation that moved to the previous whitespace. - */ - PREV_SPACE_WORD(-27), - - /** - * Operation that moved to the end of the current word. - */ - TO_END_WORD(-29), - - /** - * Operation that - */ - REPEAT_SEARCH_PREV(-34), - - /** - * Operation that - */ - PASTE_PREV(-36), - - /** - * Operation that - */ - REPLACE_MODE(-37), - - /** - * Operation that - */ - SUBSTITUTE_LINE(-38), - - /** - * Operation that - */ - TO_PREV_CHAR(-39), - - /** - * Operation that - */ - NEXT_SPACE_WORD(-40), - - /** - * Operation that - */ - DELETE_PREV_CHAR(-41), - - /** - * Operation that - */ - ADD(-42), - - /** - * Operation that - */ - PREV_WORD(-43), - - /** - * Operation that - */ - CHANGE_META(-44), - - /** - * Operation that - */ - DELETE_META(-45), - - /** - * Operation that - */ - END_WORD(-46), - - /** - * Operation that toggles insert/overtype - */ - INSERT(-48), - - /** - * Operation that - */ - REPEAT_SEARCH_NEXT(-49), - - /** - * Operation that - */ - PASTE_NEXT(-50), - - /** - * Operation that - */ - REPLACE_CHAR(-51), - - /** - * Operation that - */ - SUBSTITUTE_CHAR(-52), - - /** - * Operation that - */ - TO_NEXT_CHAR(-53), - - /** - * Operation that undoes the previous operation. - */ - UNDO(-54), - - /** - * Operation that moved to the next word. - */ - NEXT_WORD(-55), - - /** - * Operation that deletes the previous character. - */ - DELETE_NEXT_CHAR(-56), - - /** - * Operation that toggles between uppercase and lowercase. - */ - CHANGE_CASE(-57), - - /** - * Operation that performs completion operation on the current word. - */ - COMPLETE(-58), - - /** - * Operation that exits the command prompt. - */ - EXIT(-59), - - /** - * Operation that pastes the contents of the clipboard into the line - */ - PASTE(-60), - - /** - * Operation that moves the current History to the beginning. - */ - START_OF_HISTORY(-61), - - /** - * Operation that moves the current History to the end. - */ - END_OF_HISTORY(-62), - - /** - * Operation that clears whatever text is on the current line. - */ - CLEAR_LINE(-63), - - /** - * Cancel search - */ - ABORT(-64), - - /** - * Delete next word - */ - DELETE_NEXT_WORD(-65), - - ; - - public final short code; - - Operation(final int code) { - this.code = (short) code; - } - - private static final Map codes; - - static { - Map map = new HashMap(); - - for (Operation op : Operation.values()) { - map.put(op.code, op); - } - - codes = map; - } - - public static Operation valueOf(final int code) { - return codes.get((short) code); - } -} \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/console/completer/AggregateCompleter.java b/src/jline/src/main/java/scala/tools/jline/console/completer/AggregateCompleter.java deleted file mode 100644 index 3170bd1c6883..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/completer/AggregateCompleter.java +++ /dev/null @@ -1,108 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you 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 scala.tools.jline.console.completer; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.LinkedList; -import java.util.List; - -/** - * Completer which contains multiple completers and aggregates them together. - * - * @author Jason Dillon - * @since 2.3 - */ -public class AggregateCompleter - implements Completer -{ - private final List completers = new ArrayList(); - - public AggregateCompleter() { - // empty - } - - public AggregateCompleter(final Collection completers) { - assert completers != null; - this.completers.addAll(completers); - } - - public AggregateCompleter(final Completer... completers) { - this(Arrays.asList(completers)); - } - - public Collection getCompleters() { - return completers; - } - - public int complete(final String buffer, final int cursor, final List candidates) { - // buffer could be null - assert candidates != null; - - List completions = new ArrayList(completers.size()); - - // Run each completer, saving its completion results - int max = -1; - for (Completer completer : completers) { - Completion completion = new Completion(candidates); - completion.complete(completer, buffer, cursor); - - // Compute the max cursor position - max = Math.max(max, completion.cursor); - - completions.add(completion); - } - - // Append candidates from completions which have the same cursor position as max - for (Completion completion : completions) { - if (completion.cursor == max) { - candidates.addAll(completion.candidates); - } - } - - return max; - } - - @Override - public String toString() { - return getClass().getSimpleName() + "{" + - "completers=" + completers + - '}'; - } - - private class Completion - { - public final List candidates; - - public int cursor; - - public Completion(final List candidates) { - assert candidates != null; - this.candidates = new LinkedList(candidates); - } - - public void complete(final Completer completer, final String buffer, final int cursor) { - assert completer != null; - - this.cursor = completer.complete(buffer, cursor, candidates); - } - } -} diff --git a/src/jline/src/main/java/scala/tools/jline/console/completer/ArgumentCompleter.java b/src/jline/src/main/java/scala/tools/jline/console/completer/ArgumentCompleter.java deleted file mode 100644 index 6f60029a1d85..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/completer/ArgumentCompleter.java +++ /dev/null @@ -1,398 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline.console.completer; - -import scala.tools.jline.internal.Log; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.LinkedList; -import java.util.List; - -/** - * A {@link Completer} implementation that invokes a child completer using the appropriate separator argument. - * This can be used instead of the individual completers having to know about argument parsing semantics. - * - * @author Marc Prud'hommeaux - * @author Jason Dillon - * @since 2.3 - */ -public class ArgumentCompleter - implements Completer -{ - private final ArgumentDelimiter delimiter; - - private final List completers = new ArrayList(); - - private boolean strict = true; - - /** - * Create a new completer with the specified argument delimiter. - * - * @param delimiter The delimiter for parsing arguments - * @param completers The embedded completers - */ - public ArgumentCompleter(final ArgumentDelimiter delimiter, final Collection completers) { - assert delimiter != null; - this.delimiter = delimiter; - assert completers != null; - this.completers.addAll(completers); - } - - /** - * Create a new completer with the specified argument delimiter. - * - * @param delimiter The delimiter for parsing arguments - * @param completers The embedded completers - */ - public ArgumentCompleter(final ArgumentDelimiter delimiter, final Completer... completers) { - this(delimiter, Arrays.asList(completers)); - } - - /** - * Create a new completer with the default {@link WhitespaceArgumentDelimiter}. - * - * @param completers The embedded completers - */ - public ArgumentCompleter(final Completer... completers) { - this(new WhitespaceArgumentDelimiter(), completers); - } - - /** - * Create a new completer with the default {@link WhitespaceArgumentDelimiter}. - * - * @param completers The embedded completers - */ - public ArgumentCompleter(final List completers) { - this(new WhitespaceArgumentDelimiter(), completers); - } - - /** - * If true, a completion at argument index N will only succeed - * if all the completions from 0-(N-1) also succeed. - */ - public void setStrict(final boolean strict) { - this.strict = strict; - } - - /** - * Returns whether a completion at argument index N will success - * if all the completions from arguments 0-(N-1) also succeed. - * - * @return True if strict. - * @since 2.3 - */ - public boolean isStrict() { - return this.strict; - } - - /** - * @since 2.3 - */ - public ArgumentDelimiter getDelimiter() { - return delimiter; - } - - /** - * @since 2.3 - */ - public List getCompleters() { - return completers; - } - - public int complete(final String buffer, final int cursor, final List candidates) { - // buffer can be null - assert candidates != null; - - ArgumentDelimiter delim = getDelimiter(); - ArgumentList list = delim.delimit(buffer, cursor); - int argpos = list.getArgumentPosition(); - int argIndex = list.getCursorArgumentIndex(); - - if (argIndex < 0) { - return -1; - } - - List completers = getCompleters(); - Completer completer; - - // if we are beyond the end of the completers, just use the last one - if (argIndex >= completers.size()) { - completer = completers.get(completers.size() - 1); - } - else { - completer = completers.get(argIndex); - } - - // ensure that all the previous completers are successful before allowing this completer to pass (only if strict). - for (int i = 0; isStrict() && (i < argIndex); i++) { - Completer sub = completers.get(i >= completers.size() ? (completers.size() - 1) : i); - String[] args = list.getArguments(); - String arg = (args == null || i >= args.length) ? "" : args[i]; - - List subCandidates = new LinkedList(); - - if (sub.complete(arg, arg.length(), subCandidates) == -1) { - return -1; - } - - if (subCandidates.size() == 0) { - return -1; - } - } - - int ret = completer.complete(list.getCursorArgument(), argpos, candidates); - - if (ret == -1) { - return -1; - } - - int pos = ret + list.getBufferPosition() - argpos; - - // Special case: when completing in the middle of a line, and the area under the cursor is a delimiter, - // then trim any delimiters from the candidates, since we do not need to have an extra delimiter. - // - // E.g., if we have a completion for "foo", and we enter "f bar" into the buffer, and move to after the "f" - // and hit TAB, we want "foo bar" instead of "foo bar". - - if ((cursor != buffer.length()) && delim.isDelimiter(buffer, cursor)) { - for (int i = 0; i < candidates.size(); i++) { - CharSequence val = candidates.get(i); - - while (val.length() > 0 && delim.isDelimiter(val, val.length() - 1)) { - val = val.subSequence(0, val.length() - 1); - } - - candidates.set(i, val); - } - } - - Log.trace("Completing ", buffer, " (pos=", cursor, ") with: ", candidates, ": offset=", pos); - - return pos; - } - - /** - * The {@link ArgumentCompleter.ArgumentDelimiter} allows custom breaking up of a {@link String} into individual - * arguments in order to dispatch the arguments to the nested {@link Completer}. - * - * @author Marc Prud'hommeaux - */ - public static interface ArgumentDelimiter - { - /** - * Break the specified buffer into individual tokens that can be completed on their own. - * - * @param buffer The buffer to split - * @param pos The current position of the cursor in the buffer - * @return The tokens - */ - ArgumentList delimit(CharSequence buffer, int pos); - - /** - * Returns true if the specified character is a whitespace parameter. - * - * @param buffer The complete command buffer - * @param pos The index of the character in the buffer - * @return True if the character should be a delimiter - */ - boolean isDelimiter(CharSequence buffer, int pos); - } - - /** - * Abstract implementation of a delimiter that uses the {@link #isDelimiter} method to determine if a particular - * character should be used as a delimiter. - * - * @author Marc Prud'hommeaux - */ - public abstract static class AbstractArgumentDelimiter - implements ArgumentDelimiter - { - // TODO: handle argument quoting and escape characters - - private char[] quoteChars = {'\'', '"'}; - - private char[] escapeChars = {'\\'}; - - public void setQuoteChars(final char[] chars) { - this.quoteChars = chars; - } - - public char[] getQuoteChars() { - return this.quoteChars; - } - - public void setEscapeChars(final char[] chars) { - this.escapeChars = chars; - } - - public char[] getEscapeChars() { - return this.escapeChars; - } - - public ArgumentList delimit(final CharSequence buffer, final int cursor) { - List args = new LinkedList(); - StringBuilder arg = new StringBuilder(); - int argpos = -1; - int bindex = -1; - - for (int i = 0; (buffer != null) && (i <= buffer.length()); i++) { - // once we reach the cursor, set the - // position of the selected index - if (i == cursor) { - bindex = args.size(); - // the position in the current argument is just the - // length of the current argument - argpos = arg.length(); - } - - if ((i == buffer.length()) || isDelimiter(buffer, i)) { - if (arg.length() > 0) { - args.add(arg.toString()); - arg.setLength(0); // reset the arg - } - } - else { - arg.append(buffer.charAt(i)); - } - } - - return new ArgumentList(args.toArray(new String[args.size()]), bindex, argpos, cursor); - } - - /** - * Returns true if the specified character is a whitespace parameter. Check to ensure that the character is not - * escaped by any of {@link #getQuoteChars}, and is not escaped by ant of the {@link #getEscapeChars}, and - * returns true from {@link #isDelimiterChar}. - * - * @param buffer The complete command buffer - * @param pos The index of the character in the buffer - * @return True if the character should be a delimiter - */ - public boolean isDelimiter(final CharSequence buffer, final int pos) { - return !isQuoted(buffer, pos) && !isEscaped(buffer, pos) && isDelimiterChar(buffer, pos); - } - - public boolean isQuoted(final CharSequence buffer, final int pos) { - return false; - } - - public boolean isEscaped(final CharSequence buffer, final int pos) { - if (pos <= 0) { - return false; - } - - for (int i = 0; (escapeChars != null) && (i < escapeChars.length); - i++) { - if (buffer.charAt(pos) == escapeChars[i]) { - return !isEscaped(buffer, pos - 1); // escape escape - } - } - - return false; - } - - /** - * Returns true if the character at the specified position if a delimiter. This method will only be called if - * the character is not enclosed in any of the {@link #getQuoteChars}, and is not escaped by ant of the - * {@link #getEscapeChars}. To perform escaping manually, override {@link #isDelimiter} instead. - */ - public abstract boolean isDelimiterChar(CharSequence buffer, int pos); - } - - /** - * {@link ArgumentCompleter.ArgumentDelimiter} implementation that counts all whitespace (as reported by - * {@link Character#isWhitespace}) as being a delimiter. - * - * @author Marc Prud'hommeaux - */ - public static class WhitespaceArgumentDelimiter - extends AbstractArgumentDelimiter - { - /** - * The character is a delimiter if it is whitespace, and the - * preceding character is not an escape character. - */ - @Override - public boolean isDelimiterChar(final CharSequence buffer, final int pos) { - return Character.isWhitespace(buffer.charAt(pos)); - } - } - - /** - * The result of a delimited buffer. - * - * @author Marc Prud'hommeaux - */ - public static class ArgumentList - { - private String[] arguments; - - private int cursorArgumentIndex; - - private int argumentPosition; - - private int bufferPosition; - - /** - * @param arguments The array of tokens - * @param cursorArgumentIndex The token index of the cursor - * @param argumentPosition The position of the cursor in the current token - * @param bufferPosition The position of the cursor in the whole buffer - */ - public ArgumentList(final String[] arguments, final int cursorArgumentIndex, final int argumentPosition, final int bufferPosition) { - assert arguments != null; - - this.arguments = arguments; - this.cursorArgumentIndex = cursorArgumentIndex; - this.argumentPosition = argumentPosition; - this.bufferPosition = bufferPosition; - } - - public void setCursorArgumentIndex(final int i) { - this.cursorArgumentIndex = i; - } - - public int getCursorArgumentIndex() { - return this.cursorArgumentIndex; - } - - public String getCursorArgument() { - if ((cursorArgumentIndex < 0) || (cursorArgumentIndex >= arguments.length)) { - return null; - } - - return arguments[cursorArgumentIndex]; - } - - public void setArgumentPosition(final int pos) { - this.argumentPosition = pos; - } - - public int getArgumentPosition() { - return this.argumentPosition; - } - - public void setArguments(final String[] arguments) { - this.arguments = arguments; - } - - public String[] getArguments() { - return this.arguments; - } - - public void setBufferPosition(final int pos) { - this.bufferPosition = pos; - } - - public int getBufferPosition() { - return this.bufferPosition; - } - } -} diff --git a/src/jline/src/main/java/scala/tools/jline/console/completer/CandidateListCompletionHandler.java b/src/jline/src/main/java/scala/tools/jline/console/completer/CandidateListCompletionHandler.java deleted file mode 100644 index fa5bfd277777..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/completer/CandidateListCompletionHandler.java +++ /dev/null @@ -1,193 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline.console.completer; - -import scala.tools.jline.console.ConsoleReader; -import scala.tools.jline.console.CursorBuffer; - -import java.io.IOException; -import java.util.ArrayList; -import java.util.Collection; -import java.util.HashSet; -import java.util.List; -import java.util.Locale; -import java.util.ResourceBundle; -import java.util.Set; - -/** - * A {@link CompletionHandler} that deals with multiple distinct completions - * by outputting the complete list of possibilities to the console. This - * mimics the behavior of the - * readline library. - * - * @author Marc Prud'hommeaux - * @author Jason Dillon - * @since 2.3 - */ -public class CandidateListCompletionHandler - implements CompletionHandler -{ - // TODO: handle quotes and escaped quotes && enable automatic escaping of whitespace - - public boolean complete(final ConsoleReader reader, final List candidates, final int pos) throws - IOException - { - CursorBuffer buf = reader.getCursorBuffer(); - - // if there is only one completion, then fill in the buffer - if (candidates.size() == 1) { - CharSequence value = candidates.get(0); - - // fail if the only candidate is the same as the current buffer - if (value.equals(buf.toString())) { - return false; - } - - setBuffer(reader, value, pos); - - return true; - } - else if (candidates.size() > 1) { - String value = getUnambiguousCompletions(candidates); - setBuffer(reader, value, pos); - } - - printCandidates(reader, candidates); - - // redraw the current console buffer - reader.drawLine(); - - return true; - } - - public static void setBuffer(final ConsoleReader reader, final CharSequence value, final int offset) throws - IOException - { - while ((reader.getCursorBuffer().cursor > offset) && reader.backspace()) { - // empty - } - - reader.putString(value); - reader.setCursorPosition(offset + value.length()); - } - - /** - * Print out the candidates. If the size of the candidates is greater than the - * {@link ConsoleReader#getAutoprintThreshold}, they prompt with a warning. - * - * @param candidates the list of candidates to print - */ - public static void printCandidates(final ConsoleReader reader, Collection candidates) throws - IOException - { - Set distinct = new HashSet(candidates); - - if (distinct.size() > reader.getAutoprintThreshold()) { - //noinspection StringConcatenation - reader.print(Messages.DISPLAY_CANDIDATES.format(candidates.size())); - reader.flush(); - - int c; - - String noOpt = Messages.DISPLAY_CANDIDATES_NO.format(); - String yesOpt = Messages.DISPLAY_CANDIDATES_YES.format(); - char[] allowed = {yesOpt.charAt(0), noOpt.charAt(0)}; - - while ((c = reader.readCharacter(allowed)) != -1) { - String tmp = new String(new char[]{(char) c}); - - if (noOpt.startsWith(tmp)) { - reader.println(); - return; - } - else if (yesOpt.startsWith(tmp)) { - break; - } - else { - reader.beep(); - } - } - } - - // copy the values and make them distinct, without otherwise affecting the ordering. Only do it if the sizes differ. - if (distinct.size() != candidates.size()) { - Collection copy = new ArrayList(); - - for (CharSequence next : candidates) { - if (!copy.contains(next)) { - copy.add(next); - } - } - - candidates = copy; - } - - reader.println(); - reader.printColumns(candidates); - } - - /** - * Returns a root that matches all the {@link String} elements of the specified {@link List}, - * or null if there are no commonalities. For example, if the list contains - * foobar, foobaz, foobuz, the method will return foob. - */ - private String getUnambiguousCompletions(final List candidates) { - if (candidates == null || candidates.isEmpty()) { - return null; - } - - // convert to an array for speed - String[] strings = candidates.toArray(new String[candidates.size()]); - - String first = strings[0]; - StringBuilder candidate = new StringBuilder(); - - for (int i = 0; i < first.length(); i++) { - if (startsWith(first.substring(0, i + 1), strings)) { - candidate.append(first.charAt(i)); - } - else { - break; - } - } - - return candidate.toString(); - } - - /** - * @return true is all the elements of candidates start with starts - */ - private boolean startsWith(final String starts, final String[] candidates) { - for (String candidate : candidates) { - if (!candidate.startsWith(starts)) { - return false; - } - } - - return true; - } - - private static enum Messages - { - DISPLAY_CANDIDATES, - DISPLAY_CANDIDATES_YES, - DISPLAY_CANDIDATES_NO,; - - private static final - ResourceBundle - bundle = - ResourceBundle.getBundle(CandidateListCompletionHandler.class.getName(), Locale.getDefault()); - - public String format(final Object... args) { - if (bundle == null) - return ""; - else - return String.format(bundle.getString(name()), args); - } - } -} diff --git a/src/jline/src/main/java/scala/tools/jline/console/completer/Completer.java b/src/jline/src/main/java/scala/tools/jline/console/completer/Completer.java deleted file mode 100644 index 52d33847f28d..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/completer/Completer.java +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline.console.completer; - -import java.util.List; - -/** - * A completer is the mechanism by which tab-completion candidates will be resolved. - * - * @author Marc Prud'hommeaux - * @author Jason Dillon - * @since 2.3 - */ -public interface Completer -{ - // - // FIXME: Check if we can use CharSequece for buffer? - // - - /** - * Populates candidates with a list of possible completions for the buffer. - * - * The candidates list will not be sorted before being displayed to the user: thus, the - * complete method should sort the {@link List} before returning. - * - * @param buffer The buffer - * @param cursor The current position of the cursor in the buffer - * @param candidates The {@link List} of candidates to populate - * @return The index of the buffer for which the completion will be relative - */ - int complete(String buffer, int cursor, List candidates); -} diff --git a/src/jline/src/main/java/scala/tools/jline/console/completer/CompletionHandler.java b/src/jline/src/main/java/scala/tools/jline/console/completer/CompletionHandler.java deleted file mode 100644 index 030dc84205ce..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/completer/CompletionHandler.java +++ /dev/null @@ -1,25 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline.console.completer; - -import scala.tools.jline.console.ConsoleReader; - -import java.io.IOException; -import java.util.List; - -/** - * Handler for dealing with candidates for tab-completion. - * - * @author Marc Prud'hommeaux - * @author Jason Dillon - * @since 2.3 - */ -public interface CompletionHandler -{ - boolean complete(ConsoleReader reader, List candidates, int position) throws IOException; -} diff --git a/src/jline/src/main/java/scala/tools/jline/console/completer/EnumCompleter.java b/src/jline/src/main/java/scala/tools/jline/console/completer/EnumCompleter.java deleted file mode 100644 index 5ad049b857a3..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/completer/EnumCompleter.java +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright (C) 2009 the original author(s). - * - * 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 scala.tools.jline.console.completer; - -/** - * {@link Completer} for {@link Enum} names. - * - * @author Jason Dillon - * @since 2.3 - */ -public class EnumCompleter - extends StringsCompleter -{ - public EnumCompleter(Class source) { - assert source != null; - - for (Enum n : source.getEnumConstants()) { - this.getStrings().add(n.name().toLowerCase()); - } - } -} \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/console/completer/FileNameCompleter.java b/src/jline/src/main/java/scala/tools/jline/console/completer/FileNameCompleter.java deleted file mode 100644 index 655613876999..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/completer/FileNameCompleter.java +++ /dev/null @@ -1,133 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline.console.completer; - -import scala.tools.jline.internal.Configuration; - -import java.io.File; -import java.util.List; - -/** - * A file name completer takes the buffer and issues a list of - * potential completions. - *

    - * This completer tries to behave as similar as possible to - * bash's file name completion (using GNU readline) - * with the following exceptions: - *

    - *

      - *
    • Candidates that are directories will end with "/"
      • - *
    • Wildcard regular expressions are not evaluated or replaced
      • - *
    • The "~" character can be used to represent the user's home, - * but it cannot complete to other users' homes, since java does - * not provide any way of determining that easily
      • - *
    - * - * @author Marc Prud'hommeaux - * @author Jason Dillon - * @since 2.3 - */ -public class FileNameCompleter - implements Completer -{ - // TODO: Handle files with spaces in them - - private static final boolean OS_IS_WINDOWS; - - static { - String os = Configuration.getOsName(); - OS_IS_WINDOWS = os.contains("windows"); - } - - public int complete(String buffer, final int cursor, final List candidates) { - // buffer can be null - assert candidates != null; - - if (buffer == null) { - buffer = ""; - } - - if (OS_IS_WINDOWS) { - buffer = buffer.replace('/', '\\'); - } - - String translated = buffer; - - File homeDir = getUserHome(); - - // Special character: ~ maps to the user's home directory - if (translated.startsWith("~" + separator())) { - translated = homeDir.getPath() + translated.substring(1); - } - else if (translated.startsWith("~")) { - translated = homeDir.getParentFile().getAbsolutePath(); - } - else if (!(translated.startsWith(separator()))) { - String cwd = getUserDir().getAbsolutePath(); - translated = cwd + separator() + translated; - } - - File file = new File(translated); - final File dir; - - if (translated.endsWith(separator())) { - dir = file; - } - else { - dir = file.getParentFile(); - } - - File[] entries = dir == null ? new File[0] : dir.listFiles(); - - return matchFiles(buffer, translated, entries, candidates); - } - - protected String separator() { - return File.separator; - } - - protected File getUserHome() { - return Configuration.getUserHome(); - } - - protected File getUserDir() { - return new File("."); - } - - protected int matchFiles(final String buffer, final String translated, final File[] files, final List candidates) { - if (files == null) { - return -1; - } - - int matches = 0; - - // first pass: just count the matches - for (File file : files) { - if (file.getAbsolutePath().startsWith(translated)) { - matches++; - } - } - for (File file : files) { - if (file.getAbsolutePath().startsWith(translated)) { - CharSequence name = file.getName() + (matches == 1 && file.isDirectory() ? separator() : " "); - candidates.add(render(file, name).toString()); - } - } - - final int index = buffer.lastIndexOf(separator()); - - return index + separator().length(); - } - - protected CharSequence render(final File file, final CharSequence name) { - assert file != null; - assert name != null; - - return name; - } -} diff --git a/src/jline/src/main/java/scala/tools/jline/console/completer/NullCompleter.java b/src/jline/src/main/java/scala/tools/jline/console/completer/NullCompleter.java deleted file mode 100644 index 93cf563bcd10..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/completer/NullCompleter.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you 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 scala.tools.jline.console.completer; - -import java.util.List; - -/** - * Null completer. - * - * @author Marc Prud'hommeaux - * @author Jason Dillon - * @since 2.3 - */ -public final class NullCompleter - implements Completer -{ - public static final NullCompleter INSTANCE = new NullCompleter(); - - public int complete(final String buffer, final int cursor, final List candidates) { - return -1; - } -} \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/console/completer/StringsCompleter.java b/src/jline/src/main/java/scala/tools/jline/console/completer/StringsCompleter.java deleted file mode 100644 index 2abfdd03406d..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/completer/StringsCompleter.java +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you 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 scala.tools.jline.console.completer; - -import java.util.Arrays; -import java.util.Collection; -import java.util.List; -import java.util.SortedSet; -import java.util.TreeSet; - -/** - * Completer for a set of strings. - * - * @author Jason Dillon - * @since 2.3 - */ -public class StringsCompleter - implements Completer -{ - private final SortedSet strings = new TreeSet(); - - public StringsCompleter() { - // empty - } - - public StringsCompleter(final Collection strings) { - assert strings != null; - getStrings().addAll(strings); - } - - public StringsCompleter(final String... strings) { - this(Arrays.asList(strings)); - } - - public Collection getStrings() { - return strings; - } - - public int complete(final String buffer, final int cursor, final List candidates) { - // buffer could be null - assert candidates != null; - - if (buffer == null) { - candidates.addAll(strings); - } - else { - for (String match : strings.tailSet(buffer)) { - if (!match.startsWith(buffer)) { - break; - } - - candidates.add(match); - } - } - - if (candidates.size() == 1) { - candidates.set(0, candidates.get(0) + " "); - } - - return candidates.isEmpty() ? -1 : 0; - } -} \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/console/completer/package-info.java b/src/jline/src/main/java/scala/tools/jline/console/completer/package-info.java deleted file mode 100644 index 8150710cfcaa..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/completer/package-info.java +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright (C) 2010 the original author or authors. - * - * 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. - */ - -/** - * Console completer support. - * - * @since 2.3 - */ -package scala.tools.jline.console.completer; \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/console/history/FileHistory.java b/src/jline/src/main/java/scala/tools/jline/console/history/FileHistory.java deleted file mode 100644 index 5eccba3ce51b..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/history/FileHistory.java +++ /dev/null @@ -1,106 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline.console.history; - -import scala.tools.jline.internal.Log; - -import java.io.BufferedOutputStream; -import java.io.BufferedReader; -import java.io.File; -import java.io.FileOutputStream; -import java.io.FileReader; -import java.io.Flushable; -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.io.PrintStream; -import java.io.Reader; -import java.util.ListIterator; - -/** - * {@link History} using a file for persistent backing. - *

    - * Implementers should install shutdown hook to call {@link FileHistory#flush} - * to save history to disk. - * - * @author Jason Dillon - * @since 2.0 - */ -public class FileHistory - extends MemoryHistory - implements PersistentHistory, Flushable -{ - private final File file; - - public FileHistory(final File file) throws IOException { - assert file != null; - this.file = file; - load(file); - } - - public File getFile() { - return file; - } - - public void load(final File file) throws IOException { - assert file != null; - if (file.exists()) { - Log.trace("Loading history from: ", file); - load(new FileReader(file)); - } - } - - public void load(final InputStream input) throws IOException { - assert input != null; - load(new InputStreamReader(input)); - } - - public void load(final Reader reader) throws IOException { - assert reader != null; - BufferedReader input = new BufferedReader(reader); - - String item; - while ((item = input.readLine()) != null) { - add(item); - } - } - - public void flush() throws IOException { - Log.trace("Flushing history"); - - if (!file.exists()) { - File dir = file.getParentFile(); - if (!dir.exists() && !dir.mkdirs()) { - Log.warn("Failed to create directory: ", dir); - } - if (!file.createNewFile()) { - Log.warn("Failed to create file: ", file); - } - } - - PrintStream out = new PrintStream(new BufferedOutputStream(new FileOutputStream(file))); - try { - for (Entry entry : this) { - out.println(entry.value()); - } - } - finally { - out.close(); - } - } - - public void purge() throws IOException { - Log.trace("Purging history"); - - clear(); - - if (!file.delete()) { - Log.warn("Failed to delete history file: ", file); - } - } -} \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/console/history/History.java b/src/jline/src/main/java/scala/tools/jline/console/history/History.java deleted file mode 100644 index d8602f215056..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/history/History.java +++ /dev/null @@ -1,71 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline.console.history; - -import java.util.Iterator; -import java.util.ListIterator; - -/** - * Console history. - * - * @author Marc Prud'hommeaux - * @author Jason Dillon - * @since 2.3 - */ -public interface History - extends Iterable -{ - int size(); - - boolean isEmpty(); - - int index(); - - void clear(); - - CharSequence get(int index); - - void add(CharSequence line); - - void replace(CharSequence item); - - // - // Entries - // - - interface Entry - { - int index(); - - CharSequence value(); - } - - ListIterator entries(int index); - - ListIterator entries(); - - Iterator iterator(); - - // - // Navigation - // - - CharSequence current(); - - boolean previous(); - - boolean next(); - - boolean moveToFirst(); - - boolean moveToLast(); - - boolean moveTo(int index); - - void moveToEnd(); -} diff --git a/src/jline/src/main/java/scala/tools/jline/console/history/MemoryHistory.java b/src/jline/src/main/java/scala/tools/jline/console/history/MemoryHistory.java deleted file mode 100644 index 3af936428a38..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/history/MemoryHistory.java +++ /dev/null @@ -1,318 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline.console.history; - -import java.util.Iterator; -import java.util.LinkedList; -import java.util.ListIterator; -import java.util.NoSuchElementException; - -/** - * Non-persistent {@link History}. - * - * @author Marc Prud'hommeaux - * @author Jason Dillon - * @since 2.3 - */ -public class MemoryHistory - implements History -{ - public static final int DEFAULT_MAX_SIZE = 500; - - private final LinkedList items = new LinkedList(); - - private int maxSize = DEFAULT_MAX_SIZE; - - private boolean ignoreDuplicates = true; - - private boolean autoTrim = false; - - // NOTE: These are all ideas from looking at the Bash man page: - - // TODO: Add ignore space? (lines starting with a space are ignored) - - // TODO: Add ignore patterns? - - // TODO: Add history timestamp? - - // TODO: Add erase dups? - - private int offset = 0; - - private int index = 0; - - public void setMaxSize(final int maxSize) { - this.maxSize = maxSize; - maybeResize(); - } - - public int getMaxSize() { - return maxSize; - } - - public boolean isIgnoreDuplicates() { - return ignoreDuplicates; - } - - public void setIgnoreDuplicates(final boolean flag) { - this.ignoreDuplicates = flag; - } - - public boolean isAutoTrim() { - return autoTrim; - } - - public void setAutoTrim(final boolean flag) { - this.autoTrim = flag; - } - - public int size() { - return items.size(); - } - - public boolean isEmpty() { - return items.isEmpty(); - } - - public int index() { - return offset + index; - } - - public void clear() { - items.clear(); - offset = 0; - index = 0; - } - - public CharSequence get(final int index) { - return items.get(index - offset); - } - - public void add(CharSequence item) { - assert item != null; - - if (isAutoTrim()) { - item = String.valueOf(item).trim(); - } - - if (isIgnoreDuplicates()) { - if (!items.isEmpty() && item.equals(items.getLast())) { - return; - } - } - - items.add(item); - - maybeResize(); - } - - public void replace(final CharSequence item) { - items.removeLast(); - add(item); - } - - private void maybeResize() { - while (size() > getMaxSize()) { - items.removeFirst(); - offset++; - } - - index = size(); - } - - public ListIterator entries(final int index) { - return new EntriesIterator(index - offset); - } - - public ListIterator entries() { - return entries(offset); - } - - public Iterator iterator() { - return entries(); - } - - private static class EntryImpl - implements Entry - { - private final int index; - - private final CharSequence value; - - public EntryImpl(int index, CharSequence value) { - this.index = index; - this.value = value; - } - - public int index() { - return index; - } - - public CharSequence value() { - return value; - } - - @Override - public String toString() { - return String.format("%d: %s", index, value); - } - } - - private class EntriesIterator - implements ListIterator - { - private final ListIterator source; - - private EntriesIterator(final int index) { - source = items.listIterator(index); - } - - public Entry next() { - if (!source.hasNext()) { - throw new NoSuchElementException(); - } - return new EntryImpl(offset + source.nextIndex(), source.next()); - } - - public Entry previous() { - if (!source.hasPrevious()) { - throw new NoSuchElementException(); - } - return new EntryImpl(offset + source.previousIndex(), source.previous()); - } - - public int nextIndex() { - return offset + source.nextIndex(); - } - - public int previousIndex() { - return offset + source.previousIndex(); - } - - public boolean hasNext() { - return source.hasNext(); - } - - public boolean hasPrevious() { - return source.hasPrevious(); - } - - public void remove() { - throw new UnsupportedOperationException(); - } - - public void set(final Entry entry) { - throw new UnsupportedOperationException(); - } - - public void add(final Entry entry) { - throw new UnsupportedOperationException(); - } - } - - // - // Navigation - // - - /** - * This moves the history to the last entry. This entry is one position - * before the moveToEnd() position. - * - * @return Returns false if there were no history entries or the history - * index was already at the last entry. - */ - public boolean moveToLast() { - int lastEntry = size() - 1; - if (lastEntry >= 0 && lastEntry != index) { - index = size() - 1; - return true; - } - - return false; - } - - /** - * Move to the specified index in the history - * @param index - * @return - */ - public boolean moveTo(int index) { - index -= offset; - if (index >= 0 && index < size() ) { - this.index = index; - return true; - } - return false; - } - - /** - * Moves the history index to the first entry. - * - * @return Return false if there are no entries in the history or if the - * history is already at the beginning. - */ - public boolean moveToFirst() { - if (size() > 0 && index != 0) { - index = 0; - return true; - } - - return false; - } - - /** - * Move to the end of the history buffer. This will be a blank entry, after - * all of the other entries. - */ - public void moveToEnd() { - index = size(); - } - - /** - * Return the content of the current buffer. - */ - public CharSequence current() { - if (index >= size()) { - return ""; - } - - return items.get(index); - } - - /** - * Move the pointer to the previous element in the buffer. - * - * @return true if we successfully went to the previous element - */ - public boolean previous() { - if (index <= 0) { - return false; - } - - index--; - - return true; - } - - /** - * Move the pointer to the next element in the buffer. - * - * @return true if we successfully went to the next element - */ - public boolean next() { - if (index >= size()) { - return false; - } - - index++; - - return true; - } - - -} \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/console/history/PersistentHistory.java b/src/jline/src/main/java/scala/tools/jline/console/history/PersistentHistory.java deleted file mode 100644 index 916532e7fc7c..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/history/PersistentHistory.java +++ /dev/null @@ -1,34 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline.console.history; - -import java.io.IOException; - -/** - * Persistent {@link History}. - * - * @author Jason Dillon - * @since 2.3 - */ -public interface PersistentHistory - extends History -{ - /** - * Flush all items to persistent storage. - * - * @throws IOException Flush failed - */ - void flush() throws IOException; - - /** - * Purge persistent storage and {@link #clear}. - * - * @throws IOException Purge failed - */ - void purge() throws IOException; -} \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/console/history/package-info.java b/src/jline/src/main/java/scala/tools/jline/console/history/package-info.java deleted file mode 100644 index 4635752898b1..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/history/package-info.java +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright (C) 2009 the original author(s). - * - * 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. - */ - -/** - * Console history support. - * - * @since 2.0 - */ -package scala.tools.jline.console.history; \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/console/package-info.java b/src/jline/src/main/java/scala/tools/jline/console/package-info.java deleted file mode 100644 index 9f284e9c05c1..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/console/package-info.java +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright (C) 2009 the original author(s). - * - * 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. - */ - -/** - * Console support. - * - * @since 2.0 - */ -package scala.tools.jline.console; \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/internal/Configuration.java b/src/jline/src/main/java/scala/tools/jline/internal/Configuration.java deleted file mode 100644 index 5350d6c19edb..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/internal/Configuration.java +++ /dev/null @@ -1,127 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you 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 scala.tools.jline.internal; - -import java.io.BufferedInputStream; -import java.io.File; -import java.io.FileInputStream; -import java.io.IOException; -import java.io.InputStream; -import java.util.Properties; - -/** - * Provides access to configuration values. - * - * @author Jason Dillon - * @since 2.4 - */ -public final class Configuration -{ - public static final String JLINE_RC = ".jline.rc"; - - private static final Properties userprops; - - static { - Properties props = new Properties(); - - File file = new File(getUserHome(), JLINE_RC); - if (file.exists() && file.canRead()) { - try { - InputStream input = new BufferedInputStream(new FileInputStream(file)); - try { - props.load(input); - Log.debug("Loaded user configuration: ", file); - } - finally { - input.close(); - } - } - catch (IOException e) { - Log.warn("Unable to read user configuration: ", file, e); - } - } - else { - Log.trace("User configuration file missing or unreadable: ", file); - } - - userprops = props; - } - - private static boolean isEmpty(final String value) { - return value == null || value.trim().length() == 0; - } - - public static String getString(final String name, final String defaultValue) { - assert name != null; - - String value; - - // Check sysprops first, it always wins - value = System.getProperty(name); - - if (isEmpty(value)) { - // Next try userprops - value = userprops.getProperty(name); - - if (isEmpty(value)) { - // else use the default - value = defaultValue; - } - } - - return value; - } - - public static String getString(final String name) { - return getString(name, null); - } - - public static Boolean getBoolean(final String name, final Boolean defaultValue) { - String value = getString(name); - if (isEmpty(value)) { - return defaultValue; - } - return Boolean.valueOf(value); - } - - public static Boolean getBoolean(final String name) { - return getBoolean(name, null); - } - - // - // System property helpers - // - - public static File getUserHome() { - return new File(System.getProperty("user.home")); - } - - public static String getOsName() { - return System.getProperty("os.name").toLowerCase(); - } - - public static String getFileEncoding() { - return System.getProperty("file.encoding"); - } - - public static String getInputEncoding() { - return System.getProperty("input.encoding", "UTF-8"); - } -} \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/internal/Log.java b/src/jline/src/main/java/scala/tools/jline/internal/Log.java deleted file mode 100644 index b226a105325c..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/internal/Log.java +++ /dev/null @@ -1,112 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you 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 scala.tools.jline.internal; - -import java.io.PrintStream; - -/** - * Internal logger. - * - * @author Jason Dillon - * @since 2.0 - */ -public final class Log -{ - ///CLOVER:OFF - - public static enum Level - { - TRACE, - DEBUG, - INFO, - WARN, - ERROR - } - - @SuppressWarnings({"StringConcatenation"}) - public static final boolean DEBUG = Boolean.getBoolean(Log.class.getName() + ".debug"); - - @SuppressWarnings({"StringConcatenation"}) - public static final boolean TRACE = Boolean.getBoolean(Log.class.getName() + ".trace"); - - private static PrintStream output = System.err; - - public static PrintStream getOutput() { - return output; - } - - public static void setOutput(final PrintStream out) { - assert out != null; - output = out; - } - - private static void print(final Object message) { - if (message instanceof Throwable) { - ((Throwable) message).printStackTrace(); - } - else if (message.getClass().isArray()) { - Object[] array = (Object[]) message; - - for (int i = 0; i < array.length; i++) { - output.print(array[i]); - if (i + 1 < array.length) { - output.print(","); - } - } - } - else { - output.print(message); - } - } - - private static void log(final Level level, final Object[] messages) { - //noinspection SynchronizeOnNonFinalField - synchronized (output) { - output.format("[%s] ", level); - - for (Object message : messages) { - print(message); - } - - output.println(); - output.flush(); - } - } - - public static void trace(final Object... messages) { - if (TRACE) { - log(Level.TRACE, messages); - } - } - - public static void debug(final Object... messages) { - if (TRACE || DEBUG) { - log(Level.DEBUG, messages); - } - } - - public static void warn(final Object... messages) { - log(Level.WARN, messages); - } - - public static void error(final Object... messages) { - log(Level.ERROR, messages); - } -} \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/internal/ReplayPrefixOneCharInputStream.java b/src/jline/src/main/java/scala/tools/jline/internal/ReplayPrefixOneCharInputStream.java deleted file mode 100644 index 2adabdd2abd7..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/internal/ReplayPrefixOneCharInputStream.java +++ /dev/null @@ -1,95 +0,0 @@ -package scala.tools.jline.internal; - -import java.io.IOException; -import java.io.InputStream; -import java.text.MessageFormat; - -/** - * This is awkward and inefficient, but probably the minimal way to add UTF-8 support to JLine - * - * @author Marc Herbert - * @author Jason Dillon - * @since 2.0 - */ -public final class ReplayPrefixOneCharInputStream - extends InputStream -{ - private byte firstByte; - - private int byteLength; - - private InputStream wrappedStream; - - private int byteRead; - - private final String encoding; - - public ReplayPrefixOneCharInputStream(final String encoding) { - assert encoding != null; - this.encoding = encoding; - } - - public String getEncoding() { - return encoding; - } - - public void setInput(final int recorded, final InputStream wrapped) throws IOException { - this.byteRead = 0; - this.firstByte = (byte) recorded; - this.wrappedStream = wrapped; - - byteLength = 1; - if (encoding.equalsIgnoreCase("UTF-8")) { - setInputUTF8(recorded, wrapped); - } - else if (encoding.equalsIgnoreCase("UTF-16")) { - byteLength = 2; - } - else if (encoding.equalsIgnoreCase("UTF-32")) { - byteLength = 4; - } - } - - - public void setInputUTF8(final int recorded, final InputStream wrapped) throws IOException { - // 110yyyyy 10zzzzzz - if ((firstByte & (byte) 0xE0) == (byte) 0xC0) { - this.byteLength = 2; - } - // 1110xxxx 10yyyyyy 10zzzzzz - else if ((firstByte & (byte) 0xF0) == (byte) 0xE0) { - this.byteLength = 3; - } - // 11110www 10xxxxxx 10yyyyyy 10zzzzzz - else if ((firstByte & (byte) 0xF8) == (byte) 0xF0) { - this.byteLength = 4; - } - else { - throw new IOException(MessageFormat.format("Invalid UTF-8 first byte: {0}", firstByte)); - } - } - - public int read() throws IOException { - if (available() == 0) { - return -1; - } - - byteRead++; - - if (byteRead == 1) { - return firstByte; - } - - return wrappedStream.read(); - } - - /** - * InputStreamReader is greedy and will try to read bytes in advance. We - * do NOT want this to happen since we use a temporary/"losing bytes" - * InputStreamReader above, that's why we hide the real - * wrappedStream.available() here. - */ - public int available() { - return byteLength - byteRead; - } -} \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/internal/TerminalLineSettings.java b/src/jline/src/main/java/scala/tools/jline/internal/TerminalLineSettings.java deleted file mode 100644 index 151862c14d6c..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/internal/TerminalLineSettings.java +++ /dev/null @@ -1,217 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ - -package scala.tools.jline.internal; - -import java.io.ByteArrayOutputStream; -import java.io.Closeable; -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; -import java.text.MessageFormat; -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -/** - * Provides access to terminal line settings via stty. - * - * @author Marc Prud'hommeaux - * @author Dale Kemp - * @author Jason Dillon - * @author Jean-Baptiste Onofré - * @since 2.0 - */ -public final class TerminalLineSettings -{ - public static final String JLINE_STTY = "jline.stty"; - - public static final String DEFAULT_STTY = "stty"; - - public static final String JLINE_SH = "jline.sh"; - - public static final String DEFAULT_SH = "sh"; - - private static String sttyCommand = Configuration.getString(JLINE_STTY, DEFAULT_STTY); - - private static String shCommand = Configuration.getString(JLINE_SH, DEFAULT_SH); - - private String config; - - private long configLastFetched; - - public TerminalLineSettings() throws IOException, InterruptedException { - config = get("-a"); - configLastFetched = System.currentTimeMillis(); - - Log.debug("Config: ", config); - - // sanity check - if (config.length() == 0) { - throw new IOException(MessageFormat.format("Unrecognized stty code: {0}", config)); - } - } - - public String getConfig() { - return config; - } - - public void restore() throws IOException, InterruptedException { - set("sane"); - } - - public String get(final String args) throws IOException, InterruptedException { - return stty(args); - } - - public void set(final String args) throws IOException, InterruptedException { - stty(args); - } - - /** - *

    - * Get the value of a stty property, including the management of a cache. - *

    - * - * @param name the stty property. - * @return the stty property value. - */ - public int getProperty(String name) { - assert name != null; - try { - // tty properties are cached so we don't have to worry too much about getting term widht/height - if (config == null || System.currentTimeMillis() - configLastFetched > 1000 ) { - config = get("-a"); - configLastFetched = System.currentTimeMillis(); - } - return this.getProperty(name, config); - } catch (Exception e) { - Log.warn("Failed to query stty ", name, e); - return -1; - } - } - - /** - *

    - * Parses a stty output (provided by stty -a) and return the value of a given property. - *

    - * - * @param name property name. - * @param stty string resulting of stty -a execution. - * @return value of the given property. - */ - protected int getProperty(String name, String stty) { - // try the first kind of regex - Pattern pattern = Pattern.compile(name + "\\s+=\\s+([^;]*)[;\\n\\r]"); - Matcher matcher = pattern.matcher(stty); - if (!matcher.find()) { - // try a second kind of regex - pattern = Pattern.compile(name + "\\s+([^;]*)[;\\n\\r]"); - matcher = pattern.matcher(stty); - if (!matcher.find()) { - // try a second try of regex - pattern = Pattern.compile("(\\S*)\\s+" + name); - matcher = pattern.matcher(stty); - if (!matcher.find()) { - return -1; - } - } - } - return parseControlChar(matcher.group(1)); - } - - private int parseControlChar(String str) { - // under - if ("".equals(str)) { - return -1; - } - // octal - if (str.charAt(0) == '0') { - return Integer.parseInt(str, 8); - } - // decimal - if (str.charAt(0) >= '1' && str.charAt(0) <= '9') { - return Integer.parseInt(str, 10); - } - // control char - if (str.charAt(0) == '^') { - if (str.charAt(1) == '?') { - return 127; - } else { - return str.charAt(1) - 64; - } - } else if (str.charAt(0) == 'M' && str.charAt(1) == '-') { - if (str.charAt(2) == '^') { - if (str.charAt(3) == '?') { - return 127 + 128; - } else { - return str.charAt(3) - 64 + 128; - } - } else { - return str.charAt(2) + 128; - } - } else { - return str.charAt(0); - } - } - - private static String stty(final String args) throws IOException, InterruptedException { - assert args != null; - return exec(String.format("%s %s < /dev/tty", sttyCommand, args)); - } - - private static String exec(final String cmd) throws IOException, InterruptedException { - assert cmd != null; - return exec(shCommand, "-c", cmd); - } - - private static String exec(final String... cmd) throws IOException, InterruptedException { - assert cmd != null; - - ByteArrayOutputStream bout = new ByteArrayOutputStream(); - - Log.trace("Running: ", cmd); - - Process p = Runtime.getRuntime().exec(cmd); - - InputStream in = null; - InputStream err = null; - OutputStream out = null; - try { - int c; - in = p.getInputStream(); - while ((c = in.read()) != -1) { - bout.write(c); - } - err = p.getErrorStream(); - while ((c = err.read()) != -1) { - bout.write(c); - } - out = p.getOutputStream(); - p.waitFor(); - } - finally { - close(in, out, err); - } - - String result = bout.toString(); - - Log.trace("Result: ", result); - - return result; - } - - private static void close(final Closeable... closeables) { - for (Closeable c : closeables) { - try { - c.close(); - } - catch (Exception e) { - // Ignore - } - } - } -} \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/internal/package-info.java b/src/jline/src/main/java/scala/tools/jline/internal/package-info.java deleted file mode 100644 index d27444cfdfc5..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/internal/package-info.java +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright (C) 2009 the original author(s). - * - * 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. - */ - -/** - * Internal support. - * - * @since 2.0 - */ -package scala.tools.jline.internal; \ No newline at end of file diff --git a/src/jline/src/main/java/scala/tools/jline/package-info.java b/src/jline/src/main/java/scala/tools/jline/package-info.java deleted file mode 100644 index fde16f98dee6..000000000000 --- a/src/jline/src/main/java/scala/tools/jline/package-info.java +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright (C) 2009 the original author or authors. - * - * 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. - */ - -/** - * JLine 2. - * - * @since 2.0 - */ -package scala.tools.jline; \ No newline at end of file diff --git a/src/jline/src/main/resources/scala/tools/jline/console/completer/CandidateListCompletionHandler.properties b/src/jline/src/main/resources/scala/tools/jline/console/completer/CandidateListCompletionHandler.properties deleted file mode 100644 index fd097efb8a79..000000000000 --- a/src/jline/src/main/resources/scala/tools/jline/console/completer/CandidateListCompletionHandler.properties +++ /dev/null @@ -1,4 +0,0 @@ -DISPLAY_CANDIDATES=Display all %d possibilities? (y or n) -DISPLAY_CANDIDATES_YES=y -DISPLAY_CANDIDATES_NO=n -DISPLAY_MORE=--More-- diff --git a/src/jline/src/main/resources/scala/tools/jline/keybindings.properties b/src/jline/src/main/resources/scala/tools/jline/keybindings.properties deleted file mode 100644 index ad932d2a8039..000000000000 --- a/src/jline/src/main/resources/scala/tools/jline/keybindings.properties +++ /dev/null @@ -1,71 +0,0 @@ -# Keybinding mapping for JLine. The format is: -# [key code]=[logical operation] - -# CTRL-A: move to the beginning of the line -1=MOVE_TO_BEG - -# CTRL-B: move to the previous character -2=PREV_CHAR - -# CTRL-D: close out the input stream -4=EXIT - -# CTRL-E: move the cursor to the end of the line -5=MOVE_TO_END - -# CTRL-F: move to the next character -6=NEXT_CHAR - -# CTRL-G: abort -7=ABORT - -# BACKSPACE, CTRL-H: delete the previous character -# 8 is the ASCII code for backspace and therefor -# deleting the previous character -8=DELETE_PREV_CHAR - -# TAB, CTRL-I: signal that console completion should be attempted -9=COMPLETE - -# CTRL-J, CTRL-M: newline -10=NEWLINE - -# CTRL-K: erase the current line -11=KILL_LINE - -# CTRL-L: clear screen -12=CLEAR_SCREEN - -# ENTER: newline -13=NEWLINE - -# CTRL-N: scroll to the next element in the history buffer -14=NEXT_HISTORY - -# CTRL-O: move to the previous word -15=PREV_WORD - -# CTRL-P: scroll to the previous element in the history buffer -16=PREV_HISTORY - -# CTRL-R: search history -18=SEARCH_PREV - -# CTRL-T: move to next word -20=NEXT_WORD - -# CTRL-U: delete all the characters before the cursor position -21=KILL_LINE_PREV - -# CTRL-V: paste the contents of the clipboard (useful for Windows terminal) -22=PASTE - -# CTRL-W: delete the word directly before the cursor -23=DELETE_PREV_WORD - -# CTRL-X: delete the word directly after the cursor -24=DELETE_NEXT_WORD - -# DELETE, CTRL-?: delete the next character -# 127 is the ASCII code for delete -127=DELETE_NEXT_CHAR diff --git a/src/jline/src/main/resources/scala/tools/jline/windowsbindings.properties b/src/jline/src/main/resources/scala/tools/jline/windowsbindings.properties deleted file mode 100644 index 340b5aa5b98f..000000000000 --- a/src/jline/src/main/resources/scala/tools/jline/windowsbindings.properties +++ /dev/null @@ -1,71 +0,0 @@ -# Keybinding mapping for JLine. The format is: -# [key code]=[logical operation] - -# CTRL-A: move to the beginning of the line -1=MOVE_TO_BEG - -# CTRL-B: move to the previous character -2=PREV_CHAR - -# CTRL-C: toggle overtype mode (frankly, I wasn't sure where to bind this) -3=INSERT - -# CTRL-D: close out the input stream -4=EXIT - -# CTRL-E: move the cursor to the end of the line -5=MOVE_TO_END - -# CTRL-F: move to the next character -6=NEXT_CHAR - -# CTRL-G: move to the previous word -7=ABORT - -# CTRL-H: delete the previous character -8=DELETE_PREV_CHAR - -# TAB, CTRL-I: signal that console completion should be attempted -9=COMPLETE - -# CTRL-J, CTRL-M: newline -10=NEWLINE - -# CTRL-K: erase the current line -11=KILL_LINE - -# CTRL-L: clear screen -12=CLEAR_SCREEN - -# ENTER: newline -13=NEWLINE - -# CTRL-N: scroll to the next element in the history buffer -14=NEXT_HISTORY - -# CTRL-O: move to the previous word -15=PREV_WORD - -# CTRL-P: scroll to the previous element in the history buffer -16=PREV_HISTORY - -# CTRL-R: search backwards in history -18=SEARCH_PREV - -# CTRL-S: Move to the end of the history -19=END_OF_HISTORY - -# CTRL-U: delete all the characters before the cursor position -21=KILL_LINE_PREV - -# CTRL-V: paste the contents of the clipboard (useful for Windows terminal) -22=PASTE - -# CTRL-W: delete the word directly before the cursor -23=DELETE_PREV_WORD - -# CTRL-[: escape - clear the current line. -27=CLEAR_LINE - -# CTRL-?: delete the previous character -127=DELETE_NEXT_CHAR diff --git a/src/jline/src/test/java/scala/tools/jline/TerminalFactoryTest.java b/src/jline/src/test/java/scala/tools/jline/TerminalFactoryTest.java deleted file mode 100644 index c0c070bdfde7..000000000000 --- a/src/jline/src/test/java/scala/tools/jline/TerminalFactoryTest.java +++ /dev/null @@ -1,34 +0,0 @@ -package scala.tools.jline; - -import org.junit.Before; -import org.junit.Test; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; - -/** - * Tests for the {@link TerminalFactory}. - */ -public class TerminalFactoryTest -{ - @Before - public void setUp() throws Exception { - TerminalFactory.reset(); - } - - @Test - public void testConfigureNone() { - TerminalFactory.configure(TerminalFactory.NONE); - Terminal t = TerminalFactory.get(); - assertNotNull(t); - assertEquals(UnsupportedTerminal.class.getName(), t.getClass().getName()); - } - - @Test - public void testConfigureUnsupportedTerminal() { - TerminalFactory.configure(UnsupportedTerminal.class.getName()); - Terminal t = TerminalFactory.get(); - assertNotNull(t); - assertEquals(UnsupportedTerminal.class.getName(), t.getClass().getName()); - } -} \ No newline at end of file diff --git a/src/jline/src/test/java/scala/tools/jline/console/ConsoleReaderTest.java b/src/jline/src/test/java/scala/tools/jline/console/ConsoleReaderTest.java deleted file mode 100644 index 0e6cba15a0d8..000000000000 --- a/src/jline/src/test/java/scala/tools/jline/console/ConsoleReaderTest.java +++ /dev/null @@ -1,261 +0,0 @@ -package scala.tools.jline.console; - -import scala.tools.jline.TerminalFactory; -import scala.tools.jline.WindowsTerminal; -import scala.tools.jline.console.history.History; -import scala.tools.jline.console.history.MemoryHistory; -import org.junit.Before; -import org.junit.Test; - -import java.io.ByteArrayInputStream; -import java.io.InputStream; -import java.io.StringWriter; -import java.io.Writer; - -import static scala.tools.jline.WindowsTerminal.WindowsKey.DELETE_KEY; -import static scala.tools.jline.WindowsTerminal.WindowsKey.END_KEY; -import static scala.tools.jline.WindowsTerminal.WindowsKey.ESCAPE_KEY; -import static scala.tools.jline.WindowsTerminal.WindowsKey.HOME_KEY; -import static scala.tools.jline.WindowsTerminal.WindowsKey.INSERT_KEY; -import static scala.tools.jline.WindowsTerminal.WindowsKey.LEFT_ARROW_KEY; -import static scala.tools.jline.WindowsTerminal.WindowsKey.NUMPAD_KEY_INDICATOR; -import static scala.tools.jline.WindowsTerminal.WindowsKey.PAGE_DOWN_KEY; -import static scala.tools.jline.WindowsTerminal.WindowsKey.PAGE_UP_KEY; -import static scala.tools.jline.WindowsTerminal.WindowsKey.SPECIAL_KEY_INDICATOR; -import static scala.tools.jline.console.Operation.DELETE_NEXT_CHAR; -import static scala.tools.jline.console.Operation.DELETE_PREV_CHAR; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; - -/** - * Tests for the {@link ConsoleReader}. - */ -public class ConsoleReaderTest -{ - @Before - public void setUp() throws Exception { - System.setProperty(WindowsTerminal.JLINE_WINDOWS_TERMINAL_DIRECT_CONSOLE, "false"); - } - - private void assertWindowsKeyBehavior(String expected, char[] input) throws Exception { - StringBuilder buffer = new StringBuilder(); - buffer.append(input); - ConsoleReader reader = createConsole(buffer.toString().getBytes()); - assertNotNull(reader); - String line = reader.readLine(); - assertEquals(expected, line); - } - - private ConsoleReader createConsole(byte[] bytes) throws Exception { - InputStream in = new ByteArrayInputStream(bytes); - Writer writer = new StringWriter(); - ConsoleReader reader = new ConsoleReader(in, writer); - reader.setHistory(createSeededHistory()); - return reader; - } - - private History createSeededHistory() { - History history = new MemoryHistory(); - history.add("dir"); - history.add("cd c:\\"); - history.add("mkdir monkey"); - return history; - } - - @Test - public void testDeleteAndBackspaceKeymappings() throws Exception { - // test only works on Windows - if (!(TerminalFactory.get() instanceof WindowsTerminal)) { - return; - } - - ConsoleReader consoleReader = new ConsoleReader(); - assertNotNull(consoleReader); - assertEquals(127, consoleReader.getKeyForAction(DELETE_NEXT_CHAR)); - assertEquals(8, consoleReader.getKeyForAction(DELETE_PREV_CHAR)); - } - - @Test - public void testReadline() throws Exception { - ConsoleReader consoleReader = createConsole("Sample String\r\n".getBytes()); - assertNotNull(consoleReader); - String line = consoleReader.readLine(); - assertEquals("Sample String", line); - } - - @Test - public void testDeleteOnWindowsTerminal() throws Exception { - // test only works on Windows - if (!(TerminalFactory.get() instanceof WindowsTerminal)) { - return; - } - - char[] characters = new char[]{ - 'S', 's', - (char) SPECIAL_KEY_INDICATOR.code, - (char) LEFT_ARROW_KEY.code, - (char) SPECIAL_KEY_INDICATOR.code, - (char) DELETE_KEY.code, '\r', 'n' - }; - assertWindowsKeyBehavior("S", characters); - } - - @Test - public void testNumpadDeleteOnWindowsTerminal() throws Exception { - // test only works on Windows - if (!(TerminalFactory.get() instanceof WindowsTerminal)) { - return; - } - - char[] characters = new char[]{ - 'S', 's', - (char) NUMPAD_KEY_INDICATOR.code, - (char) LEFT_ARROW_KEY.code, - (char) NUMPAD_KEY_INDICATOR.code, - (char) DELETE_KEY.code, '\r', 'n' - }; - assertWindowsKeyBehavior("S", characters); - } - - @Test - public void testHomeKeyOnWindowsTerminal() throws Exception { - // test only works on Windows - if (!(TerminalFactory.get() instanceof WindowsTerminal)) { - return; - } - - char[] characters = new char[]{ - 'S', 's', - (char) SPECIAL_KEY_INDICATOR.code, - (char) HOME_KEY.code, 'x', '\r', '\n' - }; - assertWindowsKeyBehavior("xSs", characters); - - } - - @Test - public void testEndKeyOnWindowsTerminal() throws Exception { - // test only works on Windows - if (!(TerminalFactory.get() instanceof WindowsTerminal)) { - return; - } - - char[] characters = new char[]{ - 'S', 's', - (char) SPECIAL_KEY_INDICATOR.code, - (char) HOME_KEY.code, 'x', - (char) SPECIAL_KEY_INDICATOR.code, (char) END_KEY.code, - 'j', '\r', '\n' - }; - assertWindowsKeyBehavior("xSsj", characters); - } - - @Test - public void testPageUpOnWindowsTerminal() throws Exception { - // test only works on Windows - if (!(TerminalFactory.get() instanceof WindowsTerminal)) { - return; - } - - char[] characters = new char[]{ - (char) SPECIAL_KEY_INDICATOR.code, - (char) PAGE_UP_KEY.code, '\r', '\n' - }; - assertWindowsKeyBehavior("dir", characters); - } - - @Test - public void testPageDownOnWindowsTerminal() throws Exception { - // test only works on Windows - if (!(TerminalFactory.get() instanceof WindowsTerminal)) { - return; - } - - char[] characters = new char[]{ - (char) SPECIAL_KEY_INDICATOR.code, - (char) PAGE_DOWN_KEY.code, '\r', '\n' - }; - assertWindowsKeyBehavior("mkdir monkey", characters); - } - - @Test - public void testEscapeOnWindowsTerminal() throws Exception { - // test only works on Windows - if (!(TerminalFactory.get() instanceof WindowsTerminal)) { - return; - } - - char[] characters = new char[]{ - 's', 's', 's', - (char) SPECIAL_KEY_INDICATOR.code, - (char) ESCAPE_KEY.code, '\r', '\n' - }; - assertWindowsKeyBehavior("", characters); - } - - @Test - public void testInsertOnWindowsTerminal() throws Exception { - // test only works on Windows - if (!(TerminalFactory.get() instanceof WindowsTerminal)) { - return; - } - - char[] characters = new char[]{ - 'o', 'p', 's', - (char) SPECIAL_KEY_INDICATOR.code, - (char) HOME_KEY.code, - (char) SPECIAL_KEY_INDICATOR.code, - (char) INSERT_KEY.code, 'o', 'o', 'p', 's', '\r', '\n' - }; - assertWindowsKeyBehavior("oops", characters); - } - - @Test - public void testExpansion() throws Exception { - ConsoleReader reader = new ConsoleReader(); - MemoryHistory history = new MemoryHistory(); - history.setMaxSize(3); - history.add("foo"); - history.add("dir"); - history.add("cd c:\\"); - history.add("mkdir monkey"); - reader.setHistory(history); - - assertEquals("echo a!", reader.expandEvents("echo a!")); - assertEquals("mkdir monkey ; echo a!", reader.expandEvents("!! ; echo a!")); - assertEquals("echo ! a", reader.expandEvents("echo ! a")); - assertEquals("echo !\ta", reader.expandEvents("echo !\ta")); - - assertEquals("mkdir barey", reader.expandEvents("^monk^bar^")); - assertEquals("mkdir barey", reader.expandEvents("^monk^bar")); - assertEquals("a^monk^bar", reader.expandEvents("a^monk^bar")); - - assertEquals("mkdir monkey", reader.expandEvents("!!")); - assertEquals("echo echo a", reader.expandEvents("echo !#a")); - - assertEquals("mkdir monkey", reader.expandEvents("!mk")); - try { - reader.expandEvents("!mz"); - } catch (IllegalArgumentException e) { - assertEquals("!mz: event not found", e.getMessage()); - } - - assertEquals("mkdir monkey", reader.expandEvents("!?mo")); - assertEquals("mkdir monkey", reader.expandEvents("!?mo?")); - - assertEquals("mkdir monkey", reader.expandEvents("!-1")); - assertEquals("cd c:\\", reader.expandEvents("!-2")); - assertEquals("cd c:\\", reader.expandEvents("!2")); - assertEquals("mkdir monkey", reader.expandEvents("!3")); - try { - reader.expandEvents("!20"); - } catch (IllegalArgumentException e) { - assertEquals("!20: event not found", e.getMessage()); - } - try { - reader.expandEvents("!-20"); - } catch (IllegalArgumentException e) { - assertEquals("!-20: event not found", e.getMessage()); - } - } -} diff --git a/src/jline/src/test/java/scala/tools/jline/console/ConsoleReaderTestSupport.java b/src/jline/src/test/java/scala/tools/jline/console/ConsoleReaderTestSupport.java deleted file mode 100644 index c19099f0b248..000000000000 --- a/src/jline/src/test/java/scala/tools/jline/console/ConsoleReaderTestSupport.java +++ /dev/null @@ -1,143 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ -package scala.tools.jline.console; - -import scala.tools.jline.UnixTerminal; -import org.junit.Before; - -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.io.OutputStreamWriter; -import java.io.PrintWriter; - -import static scala.tools.jline.UnixTerminal.UnixKey.ARROW_DOWN; -import static scala.tools.jline.UnixTerminal.UnixKey.ARROW_LEFT; -import static scala.tools.jline.UnixTerminal.UnixKey.ARROW_PREFIX; -import static scala.tools.jline.UnixTerminal.UnixKey.ARROW_RIGHT; -import static scala.tools.jline.UnixTerminal.UnixKey.ARROW_START; -import static scala.tools.jline.UnixTerminal.UnixKey.ARROW_UP; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; - -/** - * Provides support for console reader tests. - */ -public abstract class ConsoleReaderTestSupport -{ - protected ConsoleReader console; - - @Before - public void setUp() throws Exception { - console = new ConsoleReader(null, new PrintWriter(new OutputStreamWriter(new ByteArrayOutputStream())), new UnixTerminal()); - } - - protected void assertBuffer(final String expected, final Buffer buffer) throws IOException { - assertBuffer(expected, buffer, true); - } - - protected void assertBuffer(final String expected, final Buffer buffer, final boolean clear) throws IOException { - // clear current buffer, if any - if (clear) { - console.finishBuffer(); - console.getHistory().clear(); - } - - console.setInput(new ByteArrayInputStream(buffer.getBytes())); - - // run it through the reader - while (console.readLine((String) null) != null) { - // ignore - } - - assertEquals(expected, console.getCursorBuffer().toString()); - } - - private int getKeyForAction(final Operation key) { - return getKeyForAction(key.code); - } - - private int getKeyForAction(final short logicalAction) { - int action = console.getKeyForAction(logicalAction); - - if (action == -1) { - console.printBindings(); - fail("Keystroke for logical action " + logicalAction + " was not bound in the console"); - } - - return action; - } - - protected class Buffer - { - private final ByteArrayOutputStream out = new ByteArrayOutputStream(); - - public Buffer() { - // nothing - } - - public Buffer(final String str) { - append(str); - } - - public byte[] getBytes() { - return out.toByteArray(); - } - - public Buffer op(final short operation) { - return append(getKeyForAction(operation)); - } - - public Buffer op(final Operation op) { - return op(op.code); - } - - public Buffer ctrlA() { - return append(getKeyForAction(Operation.MOVE_TO_BEG)); - } - - public Buffer ctrlU() { - return append(getKeyForAction(Operation.KILL_LINE_PREV)); - } - - public Buffer tab() { - return append(getKeyForAction(Operation.COMPLETE)); - } - - public Buffer back() { - return append(getKeyForAction(Operation.DELETE_PREV_CHAR)); - } - - public Buffer left() { - return append(ARROW_START.code).append(ARROW_PREFIX.code).append(ARROW_LEFT.code); - } - - public Buffer right() { - return append(ARROW_START.code).append(ARROW_PREFIX.code).append(ARROW_RIGHT.code); - } - - public Buffer up() { - return append(ARROW_START.code).append(ARROW_PREFIX.code).append(ARROW_UP.code); - } - - public Buffer down() { - return append(ARROW_START.code).append(ARROW_PREFIX.code).append(ARROW_DOWN.code); - } - - public Buffer append(final String str) { - for (byte b : str.getBytes()) { - append(b); - } - return this; - } - - public Buffer append(final int i) { - out.write((byte) i); - return this; - } - } -} diff --git a/src/jline/src/test/java/scala/tools/jline/console/EditLineTest.java b/src/jline/src/test/java/scala/tools/jline/console/EditLineTest.java deleted file mode 100644 index 6f5d46121e17..000000000000 --- a/src/jline/src/test/java/scala/tools/jline/console/EditLineTest.java +++ /dev/null @@ -1,208 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ -package scala.tools.jline.console; - -import org.junit.Test; - -import static scala.tools.jline.console.Operation.*; - -/** - * Tests various features of editing lines. - * - * @author Marc Prud'hommeaux - */ -public class EditLineTest - extends ConsoleReaderTestSupport -{ - @Test - public void testDeletePreviousWord() throws Exception { - Buffer b = new Buffer("This is a test"); - - assertBuffer("This is a ", b = b.op(DELETE_PREV_WORD)); - assertBuffer("This is ", b = b.op(DELETE_PREV_WORD)); - assertBuffer("This ", b = b.op(DELETE_PREV_WORD)); - assertBuffer("", b = b.op(DELETE_PREV_WORD)); - assertBuffer("", b = b.op(DELETE_PREV_WORD)); - assertBuffer("", b.op(DELETE_PREV_WORD)); - } - - @Test - public void testDeleteNextWord() throws Exception { - Buffer b = new Buffer("This is a test "); - - assertBuffer(" is a test ", b = b.op(MOVE_TO_BEG).op(DELETE_NEXT_WORD)); - assertBuffer(" a test ", b = b.op(DELETE_NEXT_WORD)); - assertBuffer(" test ", b = b.op(DELETE_NEXT_WORD)); - assertBuffer(" ", b = b.op(DELETE_NEXT_WORD)); - assertBuffer("", b = b.op(DELETE_NEXT_WORD)); - assertBuffer("", b.op(DELETE_NEXT_WORD)); - } - - @Test - public void testMoveToEnd() throws Exception { - Buffer b = new Buffer("This is a test"); - - assertBuffer("This is a XtestX", - new Buffer("This is a test").op(PREV_WORD) - .append('X') - .op(MOVE_TO_END) - .append('X')); - - assertBuffer("This is Xa testX", - new Buffer("This is a test").op(PREV_WORD) - .op(PREV_WORD) - .append('X') - .op(MOVE_TO_END) - .append('X')); - - assertBuffer("This Xis a testX", - new Buffer("This is a test").op(PREV_WORD) - .op(PREV_WORD) - .op(PREV_WORD) - .append('X') - .op(MOVE_TO_END) - .append('X')); - } - - @Test - public void testPreviousWord() throws Exception { - assertBuffer("This is a Xtest", - new Buffer("This is a test").op(PREV_WORD) - .append('X')); - assertBuffer("This is Xa test", - new Buffer("This is a test").op(PREV_WORD) - .op(PREV_WORD) - .append('X')); - assertBuffer("This Xis a test", - new Buffer("This is a test").op(PREV_WORD) - .op(PREV_WORD) - .op(PREV_WORD) - .append('X')); - assertBuffer("XThis is a test", - new Buffer("This is a test").op(PREV_WORD) - .op(PREV_WORD) - .op(PREV_WORD) - .op(PREV_WORD) - .append('X')); - assertBuffer("XThis is a test", - new Buffer("This is a test").op(PREV_WORD) - .op(PREV_WORD) - .op(PREV_WORD) - .op(PREV_WORD) - .op(PREV_WORD) - .append('X')); - assertBuffer("XThis is a test", - new Buffer("This is a test").op(PREV_WORD) - .op(PREV_WORD) - .op(PREV_WORD) - .op(PREV_WORD) - .op(PREV_WORD) - .op(PREV_WORD) - .append('X')); - } - - @Test - public void testNextWord() throws Exception { - assertBuffer("ThisX is a test", - new Buffer("This is a test").op(MOVE_TO_BEG) - .op(NEXT_WORD) - .append('X')); - assertBuffer("This isX a test", - new Buffer("This is a test").op(MOVE_TO_BEG) - .op(NEXT_WORD) - .op(NEXT_WORD) - .append('X')); - assertBuffer("This is aX test", - new Buffer("This is a test").op(MOVE_TO_BEG) - .op(NEXT_WORD) - .op(NEXT_WORD) - .op(NEXT_WORD) - .append('X')); - assertBuffer("This is a testX ", - new Buffer("This is a test ").op(MOVE_TO_BEG) - .op(NEXT_WORD) - .op(NEXT_WORD) - .op(NEXT_WORD) - .op(NEXT_WORD) - .append('X')); - } - - @Test - public void testLineStart() throws Exception { - assertBuffer("XThis is a test", - new Buffer("This is a test").ctrlA().append('X')); - assertBuffer("TXhis is a test", - new Buffer("This is a test").ctrlA().right().append('X')); - } - - @Test - public void testClearLine() throws Exception { - assertBuffer("", new Buffer("This is a test").ctrlU()); - assertBuffer("t", new Buffer("This is a test").left().ctrlU()); - assertBuffer("st", new Buffer("This is a test").left().left().ctrlU()); - } - - @Test - public void testRight() throws Exception { - Buffer b = new Buffer("This is a test"); - b = b.left().right().back(); - assertBuffer("This is a tes", b); - b = b.left().left().left().right().left().back(); - assertBuffer("This is ates", b); - b.append('X'); - assertBuffer("This is aXtes", b); - } - - @Test - public void testLeft() throws Exception { - Buffer b = new Buffer("This is a test"); - b = b.left().left().left(); - assertBuffer("This is a est", b = b.back()); - assertBuffer("This is aest", b = b.back()); - assertBuffer("This is est", b = b.back()); - assertBuffer("This isest", b = b.back()); - assertBuffer("This iest", b = b.back()); - assertBuffer("This est", b = b.back()); - assertBuffer("Thisest", b = b.back()); - assertBuffer("Thiest", b = b.back()); - assertBuffer("Thest", b = b.back()); - assertBuffer("Test", b = b.back()); - assertBuffer("est", b = b.back()); - assertBuffer("est", b = b.back()); - assertBuffer("est", b = b.back()); - assertBuffer("est", b = b.back()); - assertBuffer("est", b.back()); - } - - @Test - public void testBackspace() throws Exception { - Buffer b = new Buffer("This is a test"); - assertBuffer("This is a tes", b = b.back()); - assertBuffer("This is a te", b = b.back()); - assertBuffer("This is a t", b = b.back()); - assertBuffer("This is a ", b = b.back()); - assertBuffer("This is a", b = b.back()); - assertBuffer("This is ", b = b.back()); - assertBuffer("This is", b = b.back()); - assertBuffer("This i", b = b.back()); - assertBuffer("This ", b = b.back()); - assertBuffer("This", b = b.back()); - assertBuffer("Thi", b = b.back()); - assertBuffer("Th", b = b.back()); - assertBuffer("T", b = b.back()); - assertBuffer("", b = b.back()); - assertBuffer("", b = b.back()); - assertBuffer("", b = b.back()); - assertBuffer("", b = b.back()); - assertBuffer("", b.back()); - } - - @Test - public void testBuffer() throws Exception { - assertBuffer("This is a test", new Buffer("This is a test")); - } -} diff --git a/src/jline/src/test/java/scala/tools/jline/console/completer/ArgumentCompleterTest.java b/src/jline/src/test/java/scala/tools/jline/console/completer/ArgumentCompleterTest.java deleted file mode 100644 index 9e2a2ab031ee..000000000000 --- a/src/jline/src/test/java/scala/tools/jline/console/completer/ArgumentCompleterTest.java +++ /dev/null @@ -1,46 +0,0 @@ -/* - * Copyright (C) 2010 the original author or authors. - * - * 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 scala.tools.jline.console.completer; - -import scala.tools.jline.console.ConsoleReaderTestSupport; -import scala.tools.jline.console.completer.ArgumentCompleter; -import scala.tools.jline.console.completer.StringsCompleter; -import org.junit.Test; - -/** - * Tests for {@link jline.console.completer.ArgumentCompleter}. - * - * @author Marc Prud'hommeaux - */ -public class ArgumentCompleterTest - extends ConsoleReaderTestSupport -{ - @Test - public void test1() throws Exception { - console.addCompleter(new ArgumentCompleter(new StringsCompleter("foo", "bar", "baz"))); - - assertBuffer("foo foo ", new Buffer("foo f").tab()); - assertBuffer("foo ba", new Buffer("foo b").tab()); - assertBuffer("foo ba", new Buffer("foo ba").tab()); - assertBuffer("foo baz ", new Buffer("foo baz").tab()); - - // test completion in the mid range - assertBuffer("foo baz", new Buffer("f baz").left().left().left().left().tab()); - assertBuffer("ba foo", new Buffer("b foo").left().left().left().left().tab()); - assertBuffer("foo ba baz", new Buffer("foo b baz").left().left().left().left().tab()); - assertBuffer("foo foo baz", new Buffer("foo f baz").left().left().left().left().tab()); - } -} \ No newline at end of file diff --git a/src/jline/src/test/java/scala/tools/jline/console/completer/NullCompleterTest.java b/src/jline/src/test/java/scala/tools/jline/console/completer/NullCompleterTest.java deleted file mode 100644 index 70a4c3b554b0..000000000000 --- a/src/jline/src/test/java/scala/tools/jline/console/completer/NullCompleterTest.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Copyright (C) 2010 the original author or authors. - * - * 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 scala.tools.jline.console.completer; - -import scala.tools.jline.console.ConsoleReaderTestSupport; -import scala.tools.jline.console.completer.NullCompleter; -import org.junit.Test; - -/** - * Tests for {@link NullCompleter}. - * - * @author Jason Dillon - */ -public class NullCompleterTest - extends ConsoleReaderTestSupport -{ - @Test - public void test1() throws Exception { - console.addCompleter(NullCompleter.INSTANCE); - - assertBuffer("f", new Buffer("f").tab()); - assertBuffer("ba", new Buffer("ba").tab()); - assertBuffer("baz", new Buffer("baz").tab()); - } -} \ No newline at end of file diff --git a/src/jline/src/test/java/scala/tools/jline/console/completer/StringsCompleterTest.java b/src/jline/src/test/java/scala/tools/jline/console/completer/StringsCompleterTest.java deleted file mode 100644 index 518b88d03174..000000000000 --- a/src/jline/src/test/java/scala/tools/jline/console/completer/StringsCompleterTest.java +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright (C) 2010 the original author or authors. - * - * 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 scala.tools.jline.console.completer; - -import scala.tools.jline.console.ConsoleReaderTestSupport; -import scala.tools.jline.console.completer.StringsCompleter; -import org.junit.Test; - -/** - * Tests for {@link jline.console.completer.StringsCompleter}. - * - * @author Marc Prud'hommeaux - */ -public class StringsCompleterTest - extends ConsoleReaderTestSupport -{ - @Test - public void test1() throws Exception { - console.addCompleter(new StringsCompleter("foo", "bar", "baz")); - - assertBuffer("foo ", new Buffer("f").tab()); - // single tab completes to unambiguous "ba" - assertBuffer("ba", new Buffer("b").tab()); - assertBuffer("ba", new Buffer("ba").tab()); - assertBuffer("baz ", new Buffer("baz").tab()); - } -} \ No newline at end of file diff --git a/src/jline/src/test/java/scala/tools/jline/console/history/HistoryTest.java b/src/jline/src/test/java/scala/tools/jline/console/history/HistoryTest.java deleted file mode 100644 index 0a987b2b2662..000000000000 --- a/src/jline/src/test/java/scala/tools/jline/console/history/HistoryTest.java +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Copyright (c) 2002-2007, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ -package scala.tools.jline.console.history; - -import scala.tools.jline.console.ConsoleReaderTestSupport; -import org.junit.Test; - -import static scala.tools.jline.console.Operation.MOVE_TO_BEG; -import static scala.tools.jline.console.Operation.NEWLINE; -import static scala.tools.jline.console.Operation.NEXT_HISTORY; -import static scala.tools.jline.console.Operation.PREV_HISTORY; -import static scala.tools.jline.console.Operation.PREV_CHAR; - -/** - * Tests command history. - * - * @author Marc Prud'hommeaux - */ -public class HistoryTest - extends ConsoleReaderTestSupport -{ - @Test - public void testSingleHistory() throws Exception { - Buffer b = new Buffer(). - append("test line 1").op(NEWLINE). - append("test line 2").op(NEWLINE). - append("test line 3").op(NEWLINE). - append("test line 4").op(NEWLINE). - append("test line 5").op(NEWLINE). - append(""); - - assertBuffer("", b); - - assertBuffer("test line 5", b = b.op(PREV_HISTORY)); - assertBuffer("test line 5", b = b.op(PREV_CHAR)); - assertBuffer("test line 4", b = b.op(PREV_HISTORY)); - assertBuffer("test line 5", b = b.op(NEXT_HISTORY)); - assertBuffer("test line 4", b = b.op(PREV_HISTORY)); - assertBuffer("test line 3", b = b.op(PREV_HISTORY)); - assertBuffer("test line 2", b = b.op(PREV_HISTORY)); - assertBuffer("test line 1", b = b.op(PREV_HISTORY)); - - // beginning of history - assertBuffer("test line 1", b = b.op(PREV_HISTORY)); - assertBuffer("test line 1", b = b.op(PREV_HISTORY)); - assertBuffer("test line 1", b = b.op(PREV_HISTORY)); - assertBuffer("test line 1", b = b.op(PREV_HISTORY)); - - assertBuffer("test line 2", b = b.op(NEXT_HISTORY)); - assertBuffer("test line 3", b = b.op(NEXT_HISTORY)); - assertBuffer("test line 4", b = b.op(NEXT_HISTORY)); - assertBuffer("test line 5", b = b.op(NEXT_HISTORY)); - - // end of history - assertBuffer("", b = b.op(NEXT_HISTORY)); - assertBuffer("", b = b.op(NEXT_HISTORY)); - assertBuffer("", b = b.op(NEXT_HISTORY)); - - assertBuffer("test line 5", b = b.op(PREV_HISTORY)); - assertBuffer("test line 4", b = b.op(PREV_HISTORY)); - b = b.op(MOVE_TO_BEG).append("XXX").op(NEWLINE); - assertBuffer("XXXtest line 4", b = b.op(PREV_HISTORY)); - assertBuffer("test line 5", b = b.op(PREV_HISTORY)); - assertBuffer("test line 4", b = b.op(PREV_HISTORY)); - assertBuffer("test line 5", b = b.op(NEXT_HISTORY)); - assertBuffer("XXXtest line 4", b = b.op(NEXT_HISTORY)); - assertBuffer("", b = b.op(NEXT_HISTORY)); - - assertBuffer("XXXtest line 4", b = b.op(PREV_HISTORY)); - assertBuffer("XXXtest line 4", b = b.op(NEWLINE).op(PREV_HISTORY)); - assertBuffer("XXXtest line 4", b = b.op(NEWLINE).op(PREV_HISTORY)); - assertBuffer("XXXtest line 4", b = b.op(NEWLINE).op(PREV_HISTORY)); - assertBuffer("XXXtest line 4", b = b.op(NEWLINE).op(PREV_HISTORY)); - } -} diff --git a/src/jline/src/test/java/scala/tools/jline/console/history/MemoryHistoryTest.java b/src/jline/src/test/java/scala/tools/jline/console/history/MemoryHistoryTest.java deleted file mode 100644 index 91b81548c8c9..000000000000 --- a/src/jline/src/test/java/scala/tools/jline/console/history/MemoryHistoryTest.java +++ /dev/null @@ -1,99 +0,0 @@ -/* - * Copyright (C) 2010 the original author or authors. - * - * 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 scala.tools.jline.console.history; - -import org.junit.After; -import org.junit.Before; -import org.junit.Test; - -import static junit.framework.Assert.*; - -/** - * Tests for {@link MemoryHistory}. - * - * @author Marc Prud'hommeaux - */ -public class MemoryHistoryTest -{ - private MemoryHistory history; - - @Before - public void setUp() { - history = new MemoryHistory(); - } - - @After - public void tearDown() { - history = null; - } - - @Test - public void testAdd() { - assertEquals(0, history.size()); - - history.add("test"); - - assertEquals(1, history.size()); - assertEquals("test", history.get(0)); - assertEquals(1, history.index()); - } - - private void assertHistoryContains(final int offset, final String... items) { - assertEquals(items.length, history.size()); - int i=0; - for (History.Entry entry : history) { - assertEquals(offset + i, entry.index()); - assertEquals(items[i++], entry.value()); - } - } - - @Test - public void testOffset() { - history.setMaxSize(5); - - assertEquals(0, history.size()); - assertEquals(0, history.index()); - - history.add("a"); - history.add("b"); - history.add("c"); - history.add("d"); - history.add("e"); - - assertEquals(5, history.size()); - assertEquals(5, history.index()); - assertHistoryContains(0, "a", "b", "c", "d", "e"); - - history.add("f"); - - assertEquals(5, history.size()); - assertEquals(6, history.index()); - - assertHistoryContains(1, "b", "c", "d", "e", "f"); - assertEquals("f", history.get(5)); - } - - @Test - public void testReplace() { - assertEquals(0, history.size()); - - history.add("a"); - history.add("b"); - history.replace("c"); - - assertHistoryContains(0, "a", "c"); - } -} \ No newline at end of file diff --git a/src/jline/src/test/java/scala/tools/jline/example/Example.java b/src/jline/src/test/java/scala/tools/jline/example/Example.java deleted file mode 100644 index a89a09c5c971..000000000000 --- a/src/jline/src/test/java/scala/tools/jline/example/Example.java +++ /dev/null @@ -1,107 +0,0 @@ -/* - * Copyright (c) 2002-2006, Marc Prud'hommeaux. All rights reserved. - * - * This software is distributable under the BSD license. See the terms of the - * BSD license in the documentation provided with this software. - */ -package scala.tools.jline.example; - -import scala.tools.jline.console.completer.*; -import scala.tools.jline.console.ConsoleReader; - -import java.io.*; -import java.util.*; - -public class Example -{ - public static void usage() { - System.out.println("Usage: java " + Example.class.getName() - + " [none/simple/files/dictionary [trigger mask]]"); - System.out.println(" none - no completors"); - System.out.println(" simple - a simple completor that comples " - + "\"foo\", \"bar\", and \"baz\""); - System.out - .println(" files - a completor that comples " + "file names"); - System.out.println(" classes - a completor that comples " - + "java class names"); - System.out - .println(" trigger - a special word which causes it to assume " - + "the next line is a password"); - System.out.println(" mask - is the character to print in place of " - + "the actual password character"); - System.out.println(" color - colored prompt and feedback"); - System.out.println("\n E.g - java Example simple su '*'\n" - + "will use the simple compleator with 'su' triggering\n" - + "the use of '*' as a password mask."); - } - - public static void main(String[] args) throws IOException { - Character mask = null; - String trigger = null; - boolean color = false; - - ConsoleReader reader = new ConsoleReader(); - - reader.setBellEnabled(false); - reader.setPrompt("prompt> "); - - if ((args == null) || (args.length == 0)) { - usage(); - - return; - } - - List completors = new LinkedList(); - - if (args.length > 0) { - if (args[0].equals("none")) { - } - else if (args[0].equals("files")) { - completors.add(new FileNameCompleter()); - } - else if (args[0].equals("simple")) { - completors.add(new StringsCompleter("foo", "bar", "baz")); - } - else if (args[0].equals("color")) { - color = true; - reader.setPrompt("\u001B[1mfoo\u001B[0m@bar\u001B[32m@baz\u001B[0m> "); - } - else { - usage(); - - return; - } - } - - if (args.length == 3) { - mask = args[2].charAt(0); - trigger = args[1]; - } - - for (Completer c : completors) { - reader.addCompleter(c); - } - - String line; - PrintWriter out = new PrintWriter( - reader.getTerminal().wrapOutIfNeeded(System.out)); - - while ((line = reader.readLine()) != null) { - if (color){ - out.println("\u001B[33m======>\u001B[0m\"" + line + "\""); - } else { - out.println("======>\"" + line + "\""); - } - out.flush(); - - // If we input the special word then we will mask - // the next line. - if ((trigger != null) && (line.compareTo(trigger) == 0)) { - line = reader.readLine("password> ", mask); - } - if (line.equalsIgnoreCase("quit") || line.equalsIgnoreCase("exit")) { - break; - } - } - } -} diff --git a/src/jline/src/test/java/scala/tools/jline/internal/TerminalLineSettingsTest.java b/src/jline/src/test/java/scala/tools/jline/internal/TerminalLineSettingsTest.java deleted file mode 100644 index 3af10887f144..000000000000 --- a/src/jline/src/test/java/scala/tools/jline/internal/TerminalLineSettingsTest.java +++ /dev/null @@ -1,146 +0,0 @@ -package scala.tools.jline.internal; - -import org.junit.Before; -import org.junit.Test; - -import static org.junit.Assert.assertEquals; - -/** - * Tests for the {@link TerminalLineSettings}. - * - * @author Jean-Baptiste Onofré - */ -public class TerminalLineSettingsTest -{ - private TerminalLineSettings settings; - - private final String linuxSttySample = "speed 38400 baud; rows 85; columns 244; line = 0;\n" + - "intr = ^C; quit = ^\\; erase = ^?; kill = ^U; eof = ^D; eol = M-^?; eol2 = M-^?; swtch = M-^?; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V; flush = ^O; min = 1; time = 0;\n" + - "-parenb -parodd cs8 hupcl -cstopb cread -clocal -crtscts\n" + - "-ignbrk brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff -iuclc ixany imaxbel iutf8\n" + - "opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0\n" + - "isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke"; - - private final String solarisSttySample = "speed 38400 baud; \n" + - "rows = 85; columns = 244; ypixels = 0; xpixels = 0;\n" + - "csdata ?\n" + - "eucw 1:0:0:0, scrw 1:0:0:0\n" + - "intr = ^c; quit = ^\\; erase = ^?; kill = ^u;\n" + - "eof = ^d; eol = -^?; eol2 = -^?; swtch = ;\n" + - "start = ^q; stop = ^s; susp = ^z; dsusp = ^y;\n" + - "rprnt = ^r; flush = ^o; werase = ^w; lnext = ^v;\n" + - "-parenb -parodd cs8 -cstopb -hupcl cread -clocal -loblk -crtscts -crtsxoff -parext \n" + - "-ignbrk brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl -iuclc \n" + - "ixon ixany -ixoff imaxbel \n" + - "isig icanon -xcase echo echoe echok -echonl -noflsh \n" + - "-tostop echoctl -echoprt echoke -defecho -flusho -pendin iexten \n" + - "opost -olcuc onlcr -ocrnl -onocr -onlret -ofill -ofdel tab3"; - - private final String aixSttySample = "speed 38400 baud; 85 rows; 244 columns;\n" + - "eucw 1:1:0:0, scrw 1:1:0:0:\n" + - "intr = ^C; quit = ^\\; erase = ^?; kill = ^U; eof = ^D; eol = \n" + - "eol2 = ; start = ^Q; stop = ^S; susp = ^Z; dsusp = ^Y; reprint = ^R\n" + - "discard = ^O; werase = ^W; lnext = ^V\n" + - "-parenb -parodd cs8 -cstopb -hupcl cread -clocal -parext \n" + - "-ignbrk brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl -iuclc \n" + - "ixon ixany -ixoff imaxbel \n" + - "isig icanon -xcase echo echoe echok -echonl -noflsh \n" + - "-tostop echoctl -echoprt echoke -flusho -pending iexten \n" + - "opost -olcuc onlcr -ocrnl -onocr -onlret -ofill -ofdel tab3"; - - private final String macOsSttySample = "speed 9600 baud; 47 rows; 155 columns;\n" + - "lflags: icanon isig iexten echo echoe -echok echoke -echonl echoctl\n" + - "-echoprt -altwerase -noflsh -tostop -flusho pendin -nokerninfo\n" + - "-extproc\n" + - "iflags: -istrip icrnl -inlcr -igncr ixon -ixoff ixany imaxbel iutf8\n" + - "-ignbrk brkint -inpck -ignpar -parmrk\n" + - "oflags: opost onlcr -oxtabs -onocr -onlret\n" + - "cflags: cread cs8 -parenb -parodd hupcl -clocal -cstopb -crtscts -dsrflow\n" + - "-dtrflow -mdmbuf\n" + - "cchars: discard = ^O; dsusp = ^Y; eof = ^D; eol = ;\n" + - "eol2 = ; erase = ^?; intr = ^C; kill = ^U; lnext = ^V;\n" + - "min = 1; quit = ^\\; reprint = ^R; start = ^Q; status = ^T;\n" + - "stop = ^S; susp = ^Z; time = 0; werase = ^W;"; - - private final String netBsdSttySample = "speed 38400 baud; 85 rows; 244 columns;\n" + - "lflags: icanon isig iexten echo echoe echok echoke -echonl echoctl\n" + - " -echoprt -altwerase -noflsh -tostop -flusho pendin -nokerninfo\n" + - " -extproc\n" + - "iflags: -istrip icrnl -inlcr -igncr ixon -ixoff ixany imaxbel -ignbrk\n" + - " brkint -inpck -ignpar -parmrk\n" + - "oflags: opost onlcr -ocrnl oxtabs onocr onlret\n" + - "cflags: cread cs8 -parenb -parodd hupcl -clocal -cstopb -crtscts -mdmbuf\n" + - " -cdtrcts\n" + - "cchars: discard = ^O; dsusp = ^Y; eof = ^D; eol = ;\n" + - " eol2 = ; erase = ^?; intr = ^C; kill = ^U; lnext = ^V;\n" + - " min = 1; quit = ^\\; reprint = ^R; start = ^Q; status = ^T;\n" + - " stop = ^S; susp = ^Z; time = 0; werase = ^W;"; - - private final String freeBsdSttySample = "speed 9600 baud; 32 rows; 199 columns;\n" + - "lflags: icanon isig iexten echo echoe echok echoke -echonl echoctl\n" + - " -echoprt -altwerase -noflsh -tostop -flusho -pendin -nokerninfo\n" + - " -extproc\n" + - "iflags: -istrip icrnl -inlcr -igncr ixon -ixoff ixany imaxbel -ignbrk\n" + - " brkint -inpck -ignpar -parmrk\n" + - "oflags: opost onlcr -ocrnl tab0 -onocr -onlret\n" + - "cflags: cread cs8 -parenb -parodd hupcl -clocal -cstopb -crtscts -dsrflow\n" + - " -dtrflow -mdmbuf\n" + - "cchars: discard = ^O; dsusp = ^Y; eof = ^D; eol = ;\n" + - " eol2 = ; erase = ^?; erase2 = ^H; intr = ^C; kill = ^U;\n" + - " lnext = ^V; min = 1; quit = ^\\; reprint = ^R; start = ^Q;\n" + - " status = ^T; stop = ^S; susp = ^Z; time = 0; werase = ^W;"; - - @Before - public void setUp() throws Exception { - settings = new TerminalLineSettings(); - } - - @Test - public void testGetConfig() { - String config = settings.getConfig(); - System.out.println(config); - } - - @Test - public void testLinuxSttyParsing() { - assertEquals(0x7f, settings.getProperty("erase", linuxSttySample)); - assertEquals(244, settings.getProperty("columns", linuxSttySample)); - assertEquals(85, settings.getProperty("rows", linuxSttySample)); - } - - @Test - public void testSolarisSttyParsing() { - assertEquals(0x7f, settings.getProperty("erase", solarisSttySample)); - assertEquals(244, settings.getProperty("columns", solarisSttySample)); - assertEquals(85, settings.getProperty("rows", solarisSttySample)); - } - - @Test - public void testAixSttyParsing() { - assertEquals(0x7f, settings.getProperty("erase", aixSttySample)); - assertEquals(244, settings.getProperty("columns", aixSttySample)); - assertEquals(85, settings.getProperty("rows", aixSttySample)); - } - - @Test - public void testMacOsSttyParsing() { - assertEquals(0x7f, settings.getProperty("erase", macOsSttySample)); - assertEquals(155, settings.getProperty("columns", macOsSttySample)); - assertEquals(47, settings.getProperty("rows", macOsSttySample)); - } - - @Test - public void testNetBsdSttyParsing() { - assertEquals(0x7f, settings.getProperty("erase", netBsdSttySample)); - assertEquals(244, settings.getProperty("columns", netBsdSttySample)); - assertEquals(85, settings.getProperty("rows", netBsdSttySample)); - } - - @Test - public void testFreeBsdSttyParsing() { - assertEquals(0x7f, settings.getProperty("erase", freeBsdSttySample)); - assertEquals(199, settings.getProperty("columns", freeBsdSttySample)); - assertEquals(32, settings.getProperty("rows", freeBsdSttySample)); - } - -} \ No newline at end of file From cd2394ee43220e885bfa92f3ce34f41366bb4704 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Fri, 8 Aug 2014 21:36:27 -0700 Subject: [PATCH 461/826] SI-8787 If you love nulls, so does Regex Regex is robust when unapplying null. A null never matches. --- src/library/scala/util/matching/Regex.scala | 21 ++++++++++--------- .../junit/scala/util/matching/RegexTest.scala | 17 +++++++++++++++ 2 files changed, 28 insertions(+), 10 deletions(-) diff --git a/src/library/scala/util/matching/Regex.scala b/src/library/scala/util/matching/Regex.scala index f35ea566bab0..3d77105a1ef7 100644 --- a/src/library/scala/util/matching/Regex.scala +++ b/src/library/scala/util/matching/Regex.scala @@ -101,7 +101,7 @@ import java.util.regex.{ Pattern, Matcher } * val copyright: Option[String] = for { * dateP1(year, month, day) <- dateP1 findFirstIn "Last modified 2011-07-15" * } yield year - + * * def getYears(text: String): Iterator[String] = for (dateP1(year, _, _) <- dateP1 findAllIn text) yield year * def getFirstDay(text: String): Option[String] = for (m <- dateP2 findFirstMatchIn text) yield m group "day" * }}} @@ -154,7 +154,7 @@ import java.util.regex.{ Pattern, Matcher } * interpreted as a reference to a group in the matched pattern, with numbers * 1 through 9 corresponding to the first nine groups, and 0 standing for the * whole match. Any other character is an error. The backslash (`\`) character - * will be interpreted as an escape character, and can be used to escape the + * will be interpreted as an escape character and can be used to escape the * dollar sign. One can use [[scala.util.matching.Regex]]'s `quoteReplacement` * to automatically escape these characters. */ @@ -178,7 +178,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * * This method attempts to match the entire input by default; to find the next * matching subsequence, use an unanchored Regex. - + * * For example: * * {{{ @@ -202,10 +202,12 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * @param s The string to match * @return The matches */ - def unapplySeq(s: CharSequence): Option[List[String]] = { - val m = pattern matcher s - if (runMatcher(m)) Some((1 to m.groupCount).toList map m.group) - else None + def unapplySeq(s: CharSequence): Option[List[String]] = s match { + case null => None + case _ => + val m = pattern matcher s + if (runMatcher(m)) Some((1 to m.groupCount).toList map m.group) + else None } /** Tries to match the String representation of a [[scala.Char]]. @@ -253,7 +255,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * and the result of that match is used. */ def unapplySeq(m: Match): Option[List[String]] = - if (m.matched == null) None + if (m == null || m.matched == null) None else if (m.matcher.pattern == this.pattern) Some((1 to m.groupCount).toList map m.group) else unapplySeq(m.matched) @@ -297,7 +299,6 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends */ def findAllIn(source: CharSequence) = new Regex.MatchIterator(source, this, groupNames) - /** Return all non-overlapping matches of this regexp in given character sequence as a * [[scala.collection.Iterator]] of [[scala.util.matching.Regex.Match]]. * @@ -588,7 +589,7 @@ object Regex { } - /** Provides information about a succesful match. + /** Provides information about a successful match. */ class Match(val source: CharSequence, private[matching] val matcher: Matcher, diff --git a/test/junit/scala/util/matching/RegexTest.scala b/test/junit/scala/util/matching/RegexTest.scala index d25842cc577b..5b13397d6a69 100644 --- a/test/junit/scala/util/matching/RegexTest.scala +++ b/test/junit/scala/util/matching/RegexTest.scala @@ -27,4 +27,21 @@ class RegexTest { assertEquals("1", x) assertEquals("1", y) } + + @Test def t8787nullMatch() = { + val r = """\d+""".r + val s: String = null + val x = s match { case r() => 1 ; case _ => 2 } + assertEquals(2, x) + } + + @Test def t8787nullMatcher() = { + val r = """(\d+):(\d+)""".r + val s = "1:2 3:4 5:6" + val z = ((r findAllMatchIn s).toList :+ null) flatMap { + case r(x, y) => Some((x.toInt, y.toInt)) + case _ => None + } + assertEquals(List((1,2),(3,4),(5,6)), z) + } } From 9caf3ec7ed45a07cc82814d0146f0489be9da18e Mon Sep 17 00:00:00 2001 From: Denis Rosset Date: Sun, 10 Aug 2014 07:29:59 +0200 Subject: [PATCH 462/826] mutable.LongMap.fromZip takes collection.Iterable The type should be qualified as collection.Iterable, because Iterable is that context is mutable.Iterable. --- src/library/scala/collection/mutable/LongMap.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/library/scala/collection/mutable/LongMap.scala b/src/library/scala/collection/mutable/LongMap.scala index 984ae6f7ccb8..e0aac6574b63 100644 --- a/src/library/scala/collection/mutable/LongMap.scala +++ b/src/library/scala/collection/mutable/LongMap.scala @@ -557,7 +557,7 @@ object LongMap { /** Creates a new `LongMap` from keys and values. * Equivalent to but more efficient than `LongMap((keys zip values): _*)`. */ - def fromZip[V](keys: Iterable[Long], values: Iterable[V]): LongMap[V] = { + def fromZip[V](keys: collection.Iterable[Long], values: collection.Iterable[V]): LongMap[V] = { val sz = math.min(keys.size, values.size) val lm = new LongMap[V](sz * 2) val ki = keys.iterator From 0e26910372d349c6ff7bbaa17fc8fe0bf568c5fe Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Fri, 8 Aug 2014 22:19:59 -0700 Subject: [PATCH 463/826] SI-8787 Update doc for Regex Simplify the exposition and update the examples. Emphasize pattern matching, especially using `r.unanchored` instead of `for (r(x,y,z) <- r findFirstIn text)`. Certain details are moved to method docs. It would be nice to fix matching package doc, but the doc must attach to the package object, it seems. Introducing a package object is not binary-compatible. Includes a doc line edit on 2.12, anticipating the merge. --- src/library/scala/util/matching/Regex.scala | 309 +++++++++++--------- 1 file changed, 175 insertions(+), 134 deletions(-) diff --git a/src/library/scala/util/matching/Regex.scala b/src/library/scala/util/matching/Regex.scala index 3d77105a1ef7..3fdd256b860d 100644 --- a/src/library/scala/util/matching/Regex.scala +++ b/src/library/scala/util/matching/Regex.scala @@ -6,7 +6,6 @@ ** |/ ** \* */ - /** * This package is concerned with regular expression (regex) matching against strings, * with the main goal of pulling out information from those matches, or replacing @@ -28,117 +27,109 @@ * into a [[java.lang.String]]. * */ -package scala -package util.matching +package scala.util.matching import scala.collection.AbstractIterator import java.util.regex.{ Pattern, Matcher } -/** This class provides methods for creating and using regular expressions. - * It is based on the regular expressions of the JDK since 1.4. +/** A regular expression is used to determine whether a string matches a pattern + * and, if it does, to extract or transform the parts that match. + * + * This class delegates to the [[java.util.regex]] package of the Java Platform. + * See the documentation for [[java.util.regex.Pattern]] for details about + * the regular expression syntax for pattern strings. * - * Its main goal is to extract strings that match a pattern, or the subgroups - * that make it up. For that reason, it is usually used with for comprehensions - * and matching (see methods for examples). + * An instance of `Regex` represents a compiled regular expression pattern. + * Since compilation is expensive, frequently used `Regex`es should be constructed + * once, outside of loops and perhaps in a companion object. * - * A Regex is created from a [[java.lang.String]] representation of the - * regular expression pattern^1^. That pattern is compiled - * during construction, so frequently used patterns should be declared outside - * loops if performance is of concern. Possibly, they might be declared on a - * companion object, so that they need only to be initialized once. + * The canonical way to create a `Regex` is by using the method `r`, provided + * implicitly for strings: * - * The canonical way of creating regex patterns is by using the method `r`, provided - * on [[java.lang.String]] through an implicit conversion into - * [[scala.collection.immutable.WrappedString]]. Using triple quotes to write these - * strings avoids having to quote the backslash character (`\`). + * {{{ + * val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r + * }}} * - * Using the constructor directly, on the other hand, makes - * it possible to declare names for subgroups in the pattern. + * Since escapes are not processed in multi-line string literals, using triple quotes + * avoids having to escape the backslash character, so that `"\\d"` can be written `"""\d"""`. * - * For example, both declarations below generate the same regex, but the second - * one associate names with the subgroups. + * To extract the capturing groups when a `Regex` is matched, use it as + * an extractor in a pattern match: * * {{{ - * val dateP1 = """(\d\d\d\d)-(\d\d)-(\d\d)""".r - * val dateP2 = new scala.util.matching.Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day") + * "2004-01-20" match { + * case date(year, month, day) => s"$year was a good year for PLs." + * } * }}} * - * There are two ways of using a `Regex` to find a pattern: calling methods on - * Regex, such as `findFirstIn` or `findAllIn`, or using it as an extractor in a - * pattern match. - * - * Note that, when calling `findAllIn`, the resulting [[scala.util.matching.Regex.MatchIterator]] - * needs to be initialized (by calling `hasNext` or `next()`, or causing these to be - * called) before information about a match can be retrieved: + * To check only whether the `Regex` matches, ignoring any groups: * * {{{ - * val msg = "I love Scala" + * "2004-01-20" match { + * case date(_*) => "It's a date!" + * } + * }}} * - * // val start = " ".r.findAllIn(msg).start // throws an IllegalStateException + * In a pattern match, `Regex` normally matches the entire input. + * However, an unanchored `Regex` finds the pattern anywhere + * in the input. * - * val matches = " ".r.findAllIn(msg) - * matches.hasNext // initializes the matcher - * val start = matches.start + * {{{ + * val embeddedDate = date.unanchored + * "Date: 2004-01-20 17:25:18 GMT (10 years, 28 weeks, 5 days, 17 hours and 51 minutes ago)" match { + * case embeddedDate("2004", "01", "20") => "A Scala is born." + * } * }}} * - * When Regex is used as an extractor in a pattern match, note that it - * only succeeds if the whole text can be matched. For this reason, one usually - * calls a method to find the matching substrings, and then use it as an extractor - * to break match into subgroups. + * To find or replace matches of the pattern, use the various find and replace methods. + * There is a flavor of each method that produces matched strings and + * another that produces `Match` objects. * - * As an example, the above patterns can be used like this: + * For example, pattern matching with an unanchored `Regex`, as in the previous example, + * is the same as using `findFirstMatchIn`, except that the findFirst methods return an `Option`, + * or `None` for no match: * * {{{ - * val dateP1(year, month, day) = "2011-07-15" + * val dates = "Important dates in history: 2004-01-20, 1958-09-05, 2010-10-06, 2011-07-15" + * val firstDate = date findFirstIn dates getOrElse "No date found." + * val firstYear = for (m <- date findFirstMatchIn dates) yield m group 1 + * }}} * - * // val dateP1(year, month, day) = "Date 2011-07-15" // throws an exception at runtime + * To find all matches: * - * val copyright: String = dateP1 findFirstIn "Date of this document: 2011-07-15" match { - * case Some(dateP1(year, month, day)) => "Copyright "+year - * case None => "No copyright" - * } + * {{{ + * val allYears = for (m <- date findAllMatchIn dates) yield m group 1 + * }}} * - * val copyright: Option[String] = for { - * dateP1(year, month, day) <- dateP1 findFirstIn "Last modified 2011-07-15" - * } yield year + * But `findAllIn` returns a special iterator of strings that can be queried for the `MatchData` + * of the last match: * - * def getYears(text: String): Iterator[String] = for (dateP1(year, _, _) <- dateP1 findAllIn text) yield year - * def getFirstDay(text: String): Option[String] = for (m <- dateP2 findFirstMatchIn text) yield m group "day" + * {{{ + * val mi = date findAllIn dates + * val oldies = mi filter (_ => (mi group 1).toInt < 1960) map (s => s"$s: An oldie but goodie.") * }}} * - * Regex does not provide a method that returns a [[scala.Boolean]]. One can - * use [[java.lang.String]] `matches` method, or, if `Regex` is preferred, - * either ignore the return value or test the `Option` for emptyness. For example: + * Text replacement can be performed unconditionally or as a function of the current match: * * {{{ - * def hasDate(text: String): Boolean = (dateP1 findFirstIn text).nonEmpty - * def printLinesWithDates(lines: Traversable[String]) { - * lines foreach { line => - * dateP1 findFirstIn line foreach { _ => println(line) } - * } - * } + * val redacted = date replaceAllIn (dates, "XXXX-XX-XX") + * val yearsOnly = date replaceAllIn (dates, m => m group 1) + * val months = (0 to 11) map { i => val c = Calendar.getInstance; c.set(2014, i, 1); f"$c%tb" } + * val reformatted = date replaceAllIn (dates, _ match { case date(y,m,d) => f"${months(m.toInt - 1)} $d, $y" }) * }}} * - * There are also methods that can be used to replace the patterns - * on a text. The substitutions can be simple replacements, or more - * complex functions. For example: + * Pattern matching the `Match` against the `Regex` that created it does not reapply the `Regex`. + * In the expression for `reformatted`, each `date` match is computed once. But it is possible to apply a + * `Regex` to a `Match` resulting from a different pattern: * * {{{ - * val months = Map( 1 -> "Jan", 2 -> "Feb", 3 -> "Mar", - * 4 -> "Apr", 5 -> "May", 6 -> "Jun", - * 7 -> "Jul", 8 -> "Aug", 9 -> "Sep", - * 10 -> "Oct", 11 -> "Nov", 12 -> "Dec") - * - * import scala.util.matching.Regex.Match - * def reformatDate(text: String) = dateP2 replaceAllIn ( text, (m: Match) => - * "%s %s, %s" format (months(m group "month" toInt), m group "day", m group "year") - * ) + * val docSpree = """2011(?:-\d{2}){2}""".r + * val docView = date replaceAllIn (dates, _ match { + * case docSpree() => "Historic doc spree!" + * case _ => "Something else happened" + * }) * }}} * - * You can use special pattern syntax constructs like `(?idmsux-idmsux)`¹ to switch - * various regex compilation options like `CASE_INSENSITIVE` or `UNICODE_CASE`. - * - * @note ¹ A detailed description is available in [[java.util.regex.Pattern]]. * @see [[java.util.regex.Pattern]] * * @author Thibaud Hottelier @@ -155,8 +146,7 @@ import java.util.regex.{ Pattern, Matcher } * 1 through 9 corresponding to the first nine groups, and 0 standing for the * whole match. Any other character is an error. The backslash (`\`) character * will be interpreted as an escape character and can be used to escape the - * dollar sign. One can use [[scala.util.matching.Regex]]'s `quoteReplacement` - * to automatically escape these characters. + * dollar sign. Use `Regex.quoteReplacement` to escape these characters. */ @SerialVersionUID(-2094783597747625537L) class Regex private[matching](val pattern: Pattern, groupNames: String*) extends Serializable { @@ -164,20 +154,33 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends import Regex._ - /** - * @param regex A string representing a regular expression - * @param groupNames A mapping from names to indices in capture groups - */ + /** Compile a regular expression, supplied as a string, into a pattern that + * can be matched against inputs. + * + * If group names are supplied, they can be used this way: + * + * {{{ + * val namedDate = new Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day") + * val namedYears = for (m <- namedDate findAllMatchIn dates) yield m group "year" + * }}} + * + * This constructor does not support options as flags, which must be + * supplied as inline flags in the pattern string: `(?idmsux-idmsux)`. + * + * @param regex The regular expression to compile. + * @param groupNames Names of capturing groups. + */ def this(regex: String, groupNames: String*) = this(Pattern.compile(regex), groupNames: _*) /** Tries to match a [[java.lang.CharSequence]]. + * * If the match succeeds, the result is a list of the matching * groups (or a `null` element if a group did not match any input). * If the pattern specifies no groups, then the result will be an empty list * on a successful match. * * This method attempts to match the entire input by default; to find the next - * matching subsequence, use an unanchored Regex. + * matching subsequence, use an unanchored `Regex`. * * For example: * @@ -188,6 +191,10 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * case _ => false * } * val p2 = "a(b*)c".r + * val p2Matches = "abbbc" match { + * case p2(_*) => true + * case _ => false + * } * val numberOfB = "abbbc" match { * case p2(b) => Some(b.length) * case _ => None @@ -211,6 +218,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends } /** Tries to match the String representation of a [[scala.Char]]. + * * If the match succeeds, the result is the first matching * group if any groups are defined, or an empty Sequence otherwise. * @@ -249,8 +257,11 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends } /** Tries to match on a [[scala.util.matching.Regex.Match]]. + * * A previously failed match results in None. + * * If a successful match was made against the current pattern, then that result is used. + * * Otherwise, this Regex is applied to the previously matched input, * and the result of that match is used. */ @@ -276,25 +287,43 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends // @see UnanchoredRegex protected def runMatcher(m: Matcher) = m.matches() - /** Return all non-overlapping matches of this regexp in given character + /** Return all non-overlapping matches of this `Regex` in the given character * sequence as a [[scala.util.matching.Regex.MatchIterator]], * which is a special [[scala.collection.Iterator]] that returns the - * matched strings, but can also be converted into a normal iterator - * that returns objects of type [[scala.util.matching.Regex.Match]] - * that can be queried for data such as the text that precedes the - * match, subgroups, etc. + * matched strings but can also be queried for more data about the last match, + * such as capturing groups and start position. + * + * A `MatchIterator` can also be converted into an iterator + * that returns objects of type [[scala.util.matching.Regex.Match]], + * such as is normally returned by `findAllMatchIn`. * * Where potential matches overlap, the first possible match is returned, - * followed by the next match that is completely after the first. For - * instance, `"hat[^a]+".r` will match `hath` and `hattth` in the string - * `"hathatthattthatttt"`. + * followed by the next match that follows the input consumed by the + * first match: + * + * {{{ + * val hat = "hat[^a]+".r + * val hathaway = "hathatthattthatttt" + * val hats = (hat findAllIn hathaway).toList // List(hath, hattth) + * val pos = (hat findAllMatchIn hathaway map (_.start)).toList // List(0, 7) + * }}} * - * Attempting to retrieve information about a match before initializing - * the iterator can result in [[java.lang.IllegalStateException]]s. See - * [[scala.util.matching.Regex.MatchIterator]] for details. + * To return overlapping matches, it is possible to formulate a regular expression + * that does not consume the overlapping region. + * + * {{{ + * val madhatter = "(h)(?=(at[^a]+))".r + * val madhats = (madhatter findAllMatchIn hathaway map { + * case madhatter(x,y) => s"$x$y" + * }).toList // List(hath, hatth, hattth, hatttt) + * }}} + * + * Attempting to retrieve match information before performing the first match + * or after exhausting the iterator results in [[java.lang.IllegalStateException]]. + * See [[scala.util.matching.Regex.MatchIterator]] for details. * * @param source The text to match against. - * @return A [[scala.util.matching.Regex.MatchIterator]] of all matches. + * @return A [[scala.util.matching.Regex.MatchIterator]] of matched substrings. * @example {{{for (words <- """\w+""".r findAllIn "A simple example.") yield words}}} */ def findAllIn(source: CharSequence) = new Regex.MatchIterator(source, this, groupNames) @@ -317,8 +346,8 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends } } - /** Return optionally first matching string of this regexp in given character sequence, - * or None if it does not exist. + /** Return an optional first matching string of this `Regex` in the given character sequence, + * or None if there is no match. * * @param source The text to match against. * @return An [[scala.Option]] of the first matching string in the text. @@ -329,13 +358,11 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends if (m.find) Some(m.group) else None } - /** Return optionally first match of this regexp in given character sequence, + /** Return an optional first match of this `Regex` in the given character sequence, * or None if it does not exist. * - * The main difference between this method and `findFirstIn` is that the (optional) return - * type for this is [[scala.util.matching.Regex.Match]], through which more - * data can be obtained about the match, such as the strings that precede and follow it, - * or subgroups. + * If the match is successful, the [[scala.util.matching.Regex.Match]] can be queried for + * more data. * * @param source The text to match against. * @return A [[scala.Option]] of [[scala.util.matching.Regex.Match]] of the first matching string in the text. @@ -346,30 +373,28 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends if (m.find) Some(new Match(source, m, groupNames)) else None } - /** Return optionally match of this regexp at the beginning of the - * given character sequence, or None if regexp matches no prefix + /** Return an optional match of this `Regex` at the beginning of the + * given character sequence, or None if it matches no prefix * of the character sequence. * - * The main difference from this method to `findFirstIn` is that this - * method will not return any matches that do not begin at the start - * of the text being matched against. + * Unlike `findFirstIn`, this method will only return a match at + * the beginning of the input. * * @param source The text to match against. * @return A [[scala.Option]] of the matched prefix. - * @example {{{"""[a-z]""".r findPrefixOf "A simple example." // returns None, since the text does not begin with a lowercase letter}}} + * @example {{{"""\p{Lower}""".r findPrefixOf "A simple example." // returns None, since the text does not begin with a lowercase letter}}} */ def findPrefixOf(source: CharSequence): Option[String] = { val m = pattern.matcher(source) if (m.lookingAt) Some(m.group) else None } - /** Return optionally match of this regexp at the beginning of the - * given character sequence, or None if regexp matches no prefix + /** Return an optional match of this `Regex` at the beginning of the + * given character sequence, or None if it matches no prefix * of the character sequence. * - * The main difference from this method to `findFirstMatchIn` is that - * this method will not return any matches that do not begin at the - * start of the text being matched against. + * Unlike `findFirstMatchIn`, this method will only return a match at + * the beginning of the input. * * @param source The text to match against. * @return A [[scala.Option]] of the [[scala.util.matching.Regex.Match]] of the matched string. @@ -403,7 +428,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * import scala.util.matching.Regex * val datePattern = new Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day") * val text = "From 2011-07-15 to 2011-07-17" - * val repl = datePattern replaceAllIn (text, m => m.group("month")+"/"+m.group("day")) + * val repl = datePattern replaceAllIn (text, m => s"${m group "month"}/${m group "day"}") * }}} * * $replacementString @@ -426,10 +451,10 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * {{{ * import scala.util.matching.Regex._ * - * val map = Map("x" -> "a var", "y" -> """some $ and \ signs""") + * val vars = Map("x" -> "a var", "y" -> """some $ and \ signs""") * val text = "A text with variables %x, %y and %z." * val varPattern = """%(\w+)""".r - * val mapper = (m: Match) => map get (m group 1) map (quoteReplacement(_)) + * val mapper = (m: Match) => vars get (m group 1) map (quoteReplacement(_)) * val repl = varPattern replaceSomeIn (text, mapper) * }}} * @@ -470,17 +495,25 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends pattern.split(toSplit) /** Create a new Regex with the same pattern, but no requirement that - * the entire String matches in extractor patterns. For instance, the strings - * shown below lead to successful matches, where they would not otherwise. + * the entire String matches in extractor patterns. + * + * Normally, matching on `date` behaves as though the pattern were + * enclosed in anchors, `"^pattern$"`. + * + * The unanchored `Regex` behaves as though those anchors were removed. + * + * Note that this method does not actually strip any matchers from the pattern. + * + * Calling `anchored` returns the original `Regex`. * * {{{ - * val dateP1 = """(\d\d\d\d)-(\d\d)-(\d\d)""".r.unanchored + * val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r.unanchored * - * val dateP1(year, month, day) = "Date 2011-07-15" + * val date(year, month, day) = "Date 2011-07-15" // OK * * val copyright: String = "Date of this document: 2011-07-15" match { - * case dateP1(year, month, day) => "Copyright "+year - * case _ => "No copyright" + * case date(year, month, day) => s"Copyright $year" // OK + * case _ => "No copyright" * } * }}} * @@ -495,6 +528,10 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends override def toString = regex } +/** A [[Regex]] that finds the first match when used in a pattern match. + * + * @see [[Regex#unanchored]] + */ trait UnanchoredRegex extends Regex { override protected def runMatcher(m: Matcher) = m.find() override def unanchored = this @@ -510,30 +547,34 @@ object Regex { */ trait MatchData { - /** The source from where the match originated */ + /** The source from which the match originated */ val source: CharSequence - /** The names of the groups, or some empty sequence if one defined */ + /** The names of the groups, or an empty sequence if none defined */ val groupNames: Seq[String] - /** The number of subgroups in the pattern (not all of these need to match!) */ + /** The number of capturing groups in the pattern. + * (For a given successful match, some of those groups may not have matched any input.) + */ def groupCount: Int /** The index of the first matched character, or -1 if nothing was matched */ def start: Int /** The index of the first matched character in group `i`, - * or -1 if nothing was matched for that group */ + * or -1 if nothing was matched for that group. + */ def start(i: Int): Int - /** The index of the last matched character, or -1 if nothing was matched */ + /** The index following the last matched character, or -1 if nothing was matched. */ def end: Int /** The index following the last matched character in group `i`, - * or -1 if nothing was matched for that group */ + * or -1 if nothing was matched for that group. + */ def end(i: Int): Int - /** The matched string, or `null` if nothing was matched */ + /** The matched string, or `null` if nothing was matched. */ def matched: String = if (start >= 0) source.subSequence(start, end).toString else null @@ -544,7 +585,7 @@ object Regex { if (start(i) >= 0) source.subSequence(start(i), end(i)).toString else null - /** All matched subgroups, i.e. not including group(0) */ + /** All capturing groups, i.e., not including group(0). */ def subgroups: List[String] = (1 to groupCount).toList map group /** The char sequence before first character of match, @@ -636,15 +677,15 @@ object Regex { def unapply(m: Match): Some[String] = Some(m.matched) } - /** An extractor object that yields the groups in the match. Using an extractor - * rather than the original regex avoids recomputing the match. + /** An extractor object that yields the groups in the match. Using this extractor + * rather than the original `Regex` ensures that the match is not recomputed. * * {{{ * import scala.util.matching.Regex.Groups * - * val datePattern = """(\d\d\d\d)-(\d\d)-(\d\d)""".r + * val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r * val text = "The doc spree happened on 2011-07-15." - * val day = datePattern replaceAllIn(text, _ match { case Groups(year, month, day) => month+"/"+day }) + * val day = date replaceAllIn(text, _ match { case Groups(_, month, day) => s"$month/$day" }) * }}} */ object Groups { From 7bcb31636ccf3db2b90cec4d84b1470d2e0418f9 Mon Sep 17 00:00:00 2001 From: harryhuk Date: Tue, 3 Jun 2014 11:46:55 +0100 Subject: [PATCH 464/826] [backport] Update AnyVals.scala Corrected api doc for >> operator to say it bit-shifts right rather than left, and fills the left bits rather than the right bit (cherry picked from commit 17b99e2587251cdb02e9d96fc2f87143be3160b8) --- src/compiler/scala/tools/cmd/gen/AnyVals.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/compiler/scala/tools/cmd/gen/AnyVals.scala b/src/compiler/scala/tools/cmd/gen/AnyVals.scala index 842851b4f60d..e78589908ca2 100644 --- a/src/compiler/scala/tools/cmd/gen/AnyVals.scala +++ b/src/compiler/scala/tools/cmd/gen/AnyVals.scala @@ -111,8 +111,8 @@ import scala.language.implicitConversions""" " */"), Op(">>", "/**\n" + - " * Returns this value bit-shifted left by the specified number of bits,\n" + - " * filling in the right bits with the same value as the left-most bit of this.\n" + + " * Returns this value bit-shifted right by the specified number of bits,\n" + + " * filling in the left bits with the same value as the left-most bit of this.\n" + " * The effect of this is to retain the sign of the value.\n" + " * @example {{{\n" + " * -21 >> 3 == -3\n" + From 5321b1b0ca44ede09720ab48be981fb3bd9dcc4c Mon Sep 17 00:00:00 2001 From: Evgeny Vereshchagin Date: Sat, 31 May 2014 20:53:28 +0400 Subject: [PATCH 465/826] [backport] Make comment consistent with code (cherry picked from commit fd001811c662f6daecf91319b36c1ad14a87ff72) --- src/library/scala/Predef.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala index faeb1dcbe2bc..7f717aa6e4cb 100644 --- a/src/library/scala/Predef.scala +++ b/src/library/scala/Predef.scala @@ -303,7 +303,7 @@ object Predef extends LowPriorityImplicits with DeprecatedPredef { @inline implicit def augmentString(x: String): StringOps = new StringOps(x) @inline implicit def unaugmentString(x: StringOps): String = x.repr - // printing and reading ----------------------------------------------- + // printing ----------------------------------------------------------- def print(x: Any) = Console.print(x) def println() = Console.println() From f7e7f70a98f147007ee660d81094836e1dfea6e7 Mon Sep 17 00:00:00 2001 From: Max Bileschi Date: Thu, 12 Jun 2014 17:31:08 -0400 Subject: [PATCH 466/826] [backport] Update PartialFunction documentation to include the fact that the caller is responsible for checking 'isDefinedAt' (cherry picked from commit f7d2cec3a0c31836747a25e3cc5949d1f3cbdff4) --- src/library/scala/PartialFunction.scala | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/library/scala/PartialFunction.scala b/src/library/scala/PartialFunction.scala index 7f4a9dc45d70..865dc324046f 100644 --- a/src/library/scala/PartialFunction.scala +++ b/src/library/scala/PartialFunction.scala @@ -12,7 +12,7 @@ package scala /** A partial function of type `PartialFunction[A, B]` is a unary function * where the domain does not necessarily include all values of type `A`. * The function `isDefinedAt` allows to test dynamically if a value is in - * the domain of the function. + * the domain of the function. * * Even if `isDefinedAt` returns true for an `a: A`, calling `apply(a)` may * still throw an exception, so the following code is legal: @@ -20,6 +20,12 @@ package scala * {{{ * val f: PartialFunction[Int, Any] = { case _ => 1/0 } * }}} + * + * It is the responsibility of the caller of `apply` to check for membership + * in the domain by calling `isDefinedAt`, to ensure sanity of return values. + * A notable exception to this rule is `PartialFunction`s created with curly + * braces and case statements; In this case, a [[scala.MatchError]] is + * thrown if `isDefinedAt` (i.e. pattern matching) fails. * * The main distinction between `PartialFunction` and [[scala.Function1]] is * that the user of a `PartialFunction` may choose to do something different From 70d8aaacae0f3620dcce3a981978695eb6e9488a Mon Sep 17 00:00:00 2001 From: Max Bileschi Date: Thu, 12 Jun 2014 17:32:52 -0400 Subject: [PATCH 467/826] [backport] Update PartialFunction documentation to include the fact that the caller is responsible for checking 'isDefinedAt' (cherry picked from commit 455bcd65c055119f928b3367839f0093cf0e251a) --- src/library/scala/PartialFunction.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/library/scala/PartialFunction.scala b/src/library/scala/PartialFunction.scala index 865dc324046f..012a85d06e65 100644 --- a/src/library/scala/PartialFunction.scala +++ b/src/library/scala/PartialFunction.scala @@ -12,7 +12,7 @@ package scala /** A partial function of type `PartialFunction[A, B]` is a unary function * where the domain does not necessarily include all values of type `A`. * The function `isDefinedAt` allows to test dynamically if a value is in - * the domain of the function. + * the domain of the function. * * Even if `isDefinedAt` returns true for an `a: A`, calling `apply(a)` may * still throw an exception, so the following code is legal: From 165d21e93c3f7c8b88b29d0a590fab571ba2d534 Mon Sep 17 00:00:00 2001 From: Max Bileschi Date: Fri, 27 Jun 2014 11:44:55 -0400 Subject: [PATCH 468/826] [backport] Revised comment to appeal to lchoran's and som-snytts comments (cherry picked from commit 71bc2e5f4c49463a754a6f23e3abd2d27467fca4) --- src/library/scala/PartialFunction.scala | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/library/scala/PartialFunction.scala b/src/library/scala/PartialFunction.scala index 012a85d06e65..6f63ceb94b5a 100644 --- a/src/library/scala/PartialFunction.scala +++ b/src/library/scala/PartialFunction.scala @@ -21,11 +21,10 @@ package scala * val f: PartialFunction[Int, Any] = { case _ => 1/0 } * }}} * - * It is the responsibility of the caller of `apply` to check for membership - * in the domain by calling `isDefinedAt`, to ensure sanity of return values. - * A notable exception to this rule is `PartialFunction`s created with curly - * braces and case statements; In this case, a [[scala.MatchError]] is - * thrown if `isDefinedAt` (i.e. pattern matching) fails. + * It is the responsibility of the caller to call `isDefinedAt` before + * before calling `apply`, because if `isDefinedAt` is false, an exception + * may or may not be thrown. In the case that an exception is not thrown, + * an insane value may be returned. * * The main distinction between `PartialFunction` and [[scala.Function1]] is * that the user of a `PartialFunction` may choose to do something different From 730f311ff08fcf1a31e31200cc932511e77bc650 Mon Sep 17 00:00:00 2001 From: Max Bileschi Date: Tue, 8 Jul 2014 09:49:07 -0400 Subject: [PATCH 469/826] [backport] som-snytt's update to wording (cherry picked from commit 80a9e908fd7b591a6fe452d908407d537675a999) --- src/library/scala/PartialFunction.scala | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/library/scala/PartialFunction.scala b/src/library/scala/PartialFunction.scala index 6f63ceb94b5a..fba759eb32c9 100644 --- a/src/library/scala/PartialFunction.scala +++ b/src/library/scala/PartialFunction.scala @@ -22,9 +22,9 @@ package scala * }}} * * It is the responsibility of the caller to call `isDefinedAt` before - * before calling `apply`, because if `isDefinedAt` is false, an exception - * may or may not be thrown. In the case that an exception is not thrown, - * an insane value may be returned. + * calling `apply`, because if `isDefinedAt` is false, it is not guaranteed + * `apply` will throw an exception to indicate an error condition. If an + * exception is not thrown, evaluation may result in an arbitrary value. * * The main distinction between `PartialFunction` and [[scala.Function1]] is * that the user of a `PartialFunction` may choose to do something different From c52bceb15896cc5ec4cb0ec23cb27e656b7d58bd Mon Sep 17 00:00:00 2001 From: Evgeny Vereshchagin Date: Fri, 20 Jun 2014 17:04:10 +0400 Subject: [PATCH 470/826] [backport] Change StringContext scaladoc See e2a3498 commit message for explanation Explicit private declaration better than implicit Thanks to @som-snytt (cherry picked from commit d071abe8dd9035d8dd246ecb6b207e584b6437fa) --- src/library/scala/StringContext.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/library/scala/StringContext.scala b/src/library/scala/StringContext.scala index fe69c6fbf84a..ed3b305d59b2 100644 --- a/src/library/scala/StringContext.scala +++ b/src/library/scala/StringContext.scala @@ -38,7 +38,7 @@ import scala.annotation.tailrec * To provide your own string interpolator, create an implicit class * which adds a method to `StringContext`. Here's an example: * {{{ - * implicit class JsonHelper(val sc: StringContext) extends AnyVal { + * implicit class JsonHelper(private val sc: StringContext) extends AnyVal { * def json(args: Any*): JSONObject = ... * } * val x: JSONObject = json"{ a: $a }" From f18db59d5c580e4df1ad6bc0fe1206cc00dbce9d Mon Sep 17 00:00:00 2001 From: jxcoder Date: Wed, 2 Jul 2014 15:33:18 +0700 Subject: [PATCH 471/826] [backport] Added example to Option.collect method. (cherry picked from commit 6c698089aeb55e649a65dd7ae1bce2b4514ee865) --- src/library/scala/Option.scala | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/library/scala/Option.scala b/src/library/scala/Option.scala index 905e925f578f..5a1c832faead 100644 --- a/src/library/scala/Option.scala +++ b/src/library/scala/Option.scala @@ -251,6 +251,17 @@ sealed abstract class Option[+A] extends Product with Serializable { * nonempty '''and''' `pf` is defined for that value. * Returns $none otherwise. * + * @example {{{ + * // Returns Some(HTTP) because the partial function covers the case. + * Some("http").collect({case "http" => "HTTP"}) + * + * // Returns None because the partial function doesn't cover the case. + * Some("ftp").collect({case "http" => "HTTP"}) + * + * // Returns None because None is passed to the collect method. + * None.collect({case value => value}) + * }}} + * * @param pf the partial function. * @return the result of applying `pf` to this $option's * value (if possible), or $none. From 1c96ed5a7b5c14c0fed3f9480c4e0fbe9be2b80f Mon Sep 17 00:00:00 2001 From: jxcoder Date: Thu, 3 Jul 2014 17:16:58 +0700 Subject: [PATCH 472/826] [backport] SI-8705 Added example to Option.contains method. (cherry picked from commit 1e2a21681a4a55469faa59b07473a3b269e70258) --- src/library/scala/Option.scala | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/library/scala/Option.scala b/src/library/scala/Option.scala index 5a1c832faead..9371775d6728 100644 --- a/src/library/scala/Option.scala +++ b/src/library/scala/Option.scala @@ -210,6 +210,17 @@ sealed abstract class Option[+A] extends Product with Serializable { } /** Tests whether the option contains a given value as an element. + * + * @example {{{ + * // Returns true because Some instance contains string "something" which equals "something". + * Some("something") contains "something" + * + * // Returns false because "something" != "anything". + * Some("something") contains "anything" + * + * // Returns false when method called on None. + * None contains "anything" + * }}} * * @param elem the element to test. * @return `true` if the option has an element that is equal (as From 3b7a98911ea67c4e9e2962aeaf6defa029b632bc Mon Sep 17 00:00:00 2001 From: Maks Atygaev Date: Sat, 5 Jul 2014 10:23:23 +0700 Subject: [PATCH 473/826] [backport] [scaladoc] Changed align of example code to Option.contains and Option.collect methods. (cherry picked from commit e3311073bbad6f6f0dfdd3ea09628d324b4b3614) --- src/library/scala/Option.scala | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/src/library/scala/Option.scala b/src/library/scala/Option.scala index 9371775d6728..d263f89bb8d3 100644 --- a/src/library/scala/Option.scala +++ b/src/library/scala/Option.scala @@ -211,16 +211,16 @@ sealed abstract class Option[+A] extends Product with Serializable { /** Tests whether the option contains a given value as an element. * - * @example {{{ - * // Returns true because Some instance contains string "something" which equals "something". - * Some("something") contains "something" + * @example {{{ + * // Returns true because Some instance contains string "something" which equals "something". + * Some("something") contains "something" * - * // Returns false because "something" != "anything". - * Some("something") contains "anything" + * // Returns false because "something" != "anything". + * Some("something") contains "anything" * - * // Returns false when method called on None. - * None contains "anything" - * }}} + * // Returns false when method called on None. + * None contains "anything" + * }}} * * @param elem the element to test. * @return `true` if the option has an element that is equal (as @@ -262,16 +262,16 @@ sealed abstract class Option[+A] extends Product with Serializable { * nonempty '''and''' `pf` is defined for that value. * Returns $none otherwise. * - * @example {{{ - * // Returns Some(HTTP) because the partial function covers the case. - * Some("http").collect({case "http" => "HTTP"}) + * @example {{{ + * // Returns Some(HTTP) because the partial function covers the case. + * Some("http").collect({case "http" => "HTTP"}) * - * // Returns None because the partial function doesn't cover the case. - * Some("ftp").collect({case "http" => "HTTP"}) + * // Returns None because the partial function doesn't cover the case. + * Some("ftp").collect({case "http" => "HTTP"}) * - * // Returns None because None is passed to the collect method. - * None.collect({case value => value}) - * }}} + * // Returns None because None is passed to the collect method. + * None.collect({case value => value}) + * }}} * * @param pf the partial function. * @return the result of applying `pf` to this $option's From 9ef3d29d044da28218fea03d0c6678e281c4c550 Mon Sep 17 00:00:00 2001 From: dgruntz Date: Tue, 15 Jul 2014 00:48:39 +0200 Subject: [PATCH 474/826] [backport] Fixes first sentence delimiters Scaladoc places the first sentence in the method summary table and index. The first sentence is defined as the sequence of chars up to the first period (not as in JavaDoc where the sentence ends with the first period *followed by a blank*). As a consequence, the clause starting with `i.e.` is interpreted as sentende delimiter. This request replaces `i.e.` with `i.e.`. Alghough a valid HTML code, I do not know whether this change is compatible with other tools. And I assume that this is not the only source file affected. (cherry picked from commit c2e4da674d8c40e2d220854a966b0510fb6d459e) --- src/library/scala/concurrent/Future.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/library/scala/concurrent/Future.scala b/src/library/scala/concurrent/Future.scala index 4ed068733405..a9b7d79e637c 100644 --- a/src/library/scala/concurrent/Future.scala +++ b/src/library/scala/concurrent/Future.scala @@ -102,7 +102,7 @@ trait Future[+T] extends Awaitable[T] { /* Callbacks */ - /** When this future is completed successfully (i.e. with a value), + /** When this future is completed successfully (i.e. with a value), * apply the provided partial function to the value if the partial function * is defined at that value. * @@ -118,7 +118,7 @@ trait Future[+T] extends Awaitable[T] { case _ => } - /** When this future is completed with a failure (i.e. with a throwable), + /** When this future is completed with a failure (i.e. with a throwable), * apply the provided callback to the throwable. * * $caughtThrowables From e54b77247c5f895fe795f4ca0425d0d304cff975 Mon Sep 17 00:00:00 2001 From: Dominik Gruntz Date: Tue, 15 Jul 2014 11:04:54 +0200 Subject: [PATCH 475/826] [backport] Did not know of the fix for SI-8672. Followed the recommendation given by som-snytt. (cherry picked from commit ec4abf5483e890976ae460252e80a66a95674e61) --- src/library/scala/concurrent/Future.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/library/scala/concurrent/Future.scala b/src/library/scala/concurrent/Future.scala index a9b7d79e637c..e93a3284dc33 100644 --- a/src/library/scala/concurrent/Future.scala +++ b/src/library/scala/concurrent/Future.scala @@ -102,7 +102,7 @@ trait Future[+T] extends Awaitable[T] { /* Callbacks */ - /** When this future is completed successfully (i.e. with a value), + /** When this future is completed successfully (i.e., with a value), * apply the provided partial function to the value if the partial function * is defined at that value. * @@ -118,7 +118,7 @@ trait Future[+T] extends Awaitable[T] { case _ => } - /** When this future is completed with a failure (i.e. with a throwable), + /** When this future is completed with a failure (i.e., with a throwable), * apply the provided callback to the throwable. * * $caughtThrowables From b70b074d20edf0001dce5c14775ee96054b9bae2 Mon Sep 17 00:00:00 2001 From: Lukas Elmer Date: Mon, 21 Jul 2014 23:00:05 +0200 Subject: [PATCH 476/826] [backport] Fix scaladoc typo (cherry picked from commit 0a1694d8048f01b7f0812cedaa341813e9044e7f) --- src/library/scala/math/Ordering.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/library/scala/math/Ordering.scala b/src/library/scala/math/Ordering.scala index d1a4e7c35c91..0d7ea8bce233 100644 --- a/src/library/scala/math/Ordering.scala +++ b/src/library/scala/math/Ordering.scala @@ -26,7 +26,7 @@ import scala.language.{implicitConversions, higherKinds} * val pairs = Array(("a", 5, 2), ("c", 3, 1), ("b", 1, 3)) * * // sort by 2nd element - * Sorting.quickSort(pairs)(Ordering.by[(String, Int, Int), Int](_._2) + * Sorting.quickSort(pairs)(Ordering.by[(String, Int, Int), Int](_._2)) * * // sort by the 3rd element, then 1st * Sorting.quickSort(pairs)(Ordering[(Int, String)].on(x => (x._3, x._1))) From cb2cfc0bf608a45c5a9948152aae55ce455c4e14 Mon Sep 17 00:00:00 2001 From: Malte Isberner Date: Mon, 21 Jul 2014 22:10:09 -0700 Subject: [PATCH 477/826] [backport] Fixed mathematically wrong statement in the documentation of scala.math.PartialOrdering. - Previous (misleading) documentation suggested that a partial ordering *is* an equivalence relation. This has now been clarified. - Existing documentation on properties of partial orderings (reflexive, transitive, antisymmetric) had several formatting inconsistencies that have now been remove. (cherry picked from commit 528df5becee03175e7462b64d7c22460cc5992f7) --- src/library/scala/math/PartialOrdering.scala | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/src/library/scala/math/PartialOrdering.scala b/src/library/scala/math/PartialOrdering.scala index 9e3538152848..8d7fc3253550 100644 --- a/src/library/scala/math/PartialOrdering.scala +++ b/src/library/scala/math/PartialOrdering.scala @@ -15,17 +15,24 @@ package math * latter. * * A [[http://en.wikipedia.org/wiki/Partial_order partial ordering]] is a - * binary relation on a type `T` that is also an equivalence relation on - * values of type `T`. This relation is exposed as the `lteq` method of - * the `PartialOrdering` trait. This relation must be: + * binary relation on a type `T`, exposed as the `lteq` method of this trait. + * This relation must be: * * - reflexive: `lteq(x, x) == '''true'''`, for any `x` of type `T`. - * - anti-symmetric: `lteq(x, y) == '''true'''` and `lteq(y, x) == true` - * then `equiv(x, y)`, for any `x` and `y` of type `T`. + * - anti-symmetric: if `lteq(x, y) == '''true'''` and + * `lteq(y, x) == '''true'''` + * then `equiv(x, y) == '''true'''`, for any `x` and `y` of type `T`. * - transitive: if `lteq(x, y) == '''true'''` and * `lteq(y, z) == '''true'''` then `lteq(x, z) == '''true'''`, * for any `x`, `y`, and `z` of type `T`. * + * Additionally, a partial ordering induces an + * [[http://en.wikipedia.org/wiki/Equivalence_relation equivalence relation]] + * on a type `T`: `x` and `y` of type `T` are equivalent if and only if + * `lteq(x, y) && lteq(y, x) == '''true'''`. This equivalence relation is + * exposed as the `equiv` method, inherited from the + * [[scala.math.Equiv Equiv]] trait. + * * @author Geoffrey Washburn * @version 1.0, 2008-04-0-3 * @since 2.7 From 2b78c32b42b55b96834df31824fdb081a095cf5f Mon Sep 17 00:00:00 2001 From: jxcoder Date: Thu, 3 Jul 2014 11:02:49 +0700 Subject: [PATCH 478/826] [backport] Refactored example to Option.collect method. (cherry picked from commit 7cca7635b392cb533d0f8e26b74d7362c0dd3891) --- src/library/scala/Option.scala | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/library/scala/Option.scala b/src/library/scala/Option.scala index d263f89bb8d3..66900e725801 100644 --- a/src/library/scala/Option.scala +++ b/src/library/scala/Option.scala @@ -264,13 +264,13 @@ sealed abstract class Option[+A] extends Product with Serializable { * * @example {{{ * // Returns Some(HTTP) because the partial function covers the case. - * Some("http").collect({case "http" => "HTTP"}) + * Some("http") collect {case "http" => "HTTP"} * * // Returns None because the partial function doesn't cover the case. - * Some("ftp").collect({case "http" => "HTTP"}) + * Some("ftp") collect {case "http" => "HTTP"} * * // Returns None because None is passed to the collect method. - * None.collect({case value => value}) + * None collect {case value => value} * }}} * * @param pf the partial function. From 5cb672bdc6e8a662ddc68a07811956e78a134acf Mon Sep 17 00:00:00 2001 From: Dominik Gruntz Date: Wed, 6 Aug 2014 17:12:20 +0200 Subject: [PATCH 479/826] [backport] Fixes cut sentences in the generated scaladocs This commit changes all first sentences of library functions which contain `i.e.` or `e.g.` and adds a `,` to prevent that the scaladoc summary sentence is cut after this abbreviation. This is possible as pull/3824 fixed how Scaladoc parses the first sentence of a method description into a sumary sentence(now the first sentence has to end with a dot followed by whitespace). Only docs in the core library are changed (src/library/**/*.scala) and only if they occur in the first sentence. Review by @heathermiller (cherry picked from commit 72721ff5dd06dea1235ecb71acae0bd61aee4814) --- src/library/scala/collection/GenMapLike.scala | 2 +- src/library/scala/collection/TraversableOnce.scala | 2 +- src/library/scala/collection/immutable/Stream.scala | 2 +- src/library/scala/collection/immutable/StringLike.scala | 4 ++-- src/library/scala/concurrent/duration/Deadline.scala | 6 +++--- src/library/scala/math/BigDecimal.scala | 6 +++--- src/library/scala/math/BigInt.scala | 6 +++--- src/library/scala/runtime/ScalaRunTime.scala | 2 +- src/library/scala/sys/Prop.scala | 2 +- src/library/scala/util/Properties.scala | 2 +- src/library/scala/util/matching/Regex.scala | 2 +- 11 files changed, 18 insertions(+), 18 deletions(-) diff --git a/src/library/scala/collection/GenMapLike.scala b/src/library/scala/collection/GenMapLike.scala index 4e7d35925106..bce974052247 100644 --- a/src/library/scala/collection/GenMapLike.scala +++ b/src/library/scala/collection/GenMapLike.scala @@ -102,7 +102,7 @@ trait GenMapLike[A, +B, +Repr] extends GenIterableLike[(A, B), Repr] with Equals */ def mapValues[C](f: B => C): GenMap[A, C] - /** Compares two maps structurally; i.e. checks if all mappings + /** Compares two maps structurally; i.e., checks if all mappings * contained in this map are also contained in the other map, * and vice versa. * diff --git a/src/library/scala/collection/TraversableOnce.scala b/src/library/scala/collection/TraversableOnce.scala index a8c4e047ab05..13cd99d91044 100644 --- a/src/library/scala/collection/TraversableOnce.scala +++ b/src/library/scala/collection/TraversableOnce.scala @@ -75,7 +75,7 @@ trait TraversableOnce[+A] extends Any with GenTraversableOnce[A] { // at least indirectly. Currently, these are `ArrayOps` and `StringOps`. // It is also implemented in `TraversableOnce[A]`. /** A version of this collection with all - * of the operations implemented sequentially (i.e. in a single-threaded manner). + * of the operations implemented sequentially (i.e., in a single-threaded manner). * * This method returns a reference to this collection. In parallel collections, * it is redefined to return a sequential implementation of this collection. In diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala index d3ff5e8abf42..37a0b373da04 100644 --- a/src/library/scala/collection/immutable/Stream.scala +++ b/src/library/scala/collection/immutable/Stream.scala @@ -469,7 +469,7 @@ self => else super.flatMap(f)(bf) /** Returns all the elements of this `Stream` that satisfy the predicate `p` - * in a new `Stream` - i.e. it is still a lazy data structure. The order of + * in a new `Stream` - i.e., it is still a lazy data structure. The order of * the elements is preserved * * @param p the predicate used to filter the stream. diff --git a/src/library/scala/collection/immutable/StringLike.scala b/src/library/scala/collection/immutable/StringLike.scala index 8e1d950d00fc..738b294ce669 100644 --- a/src/library/scala/collection/immutable/StringLike.scala +++ b/src/library/scala/collection/immutable/StringLike.scala @@ -121,14 +121,14 @@ self => } /** Return all lines in this string in an iterator, excluding trailing line - * end characters, i.e. apply `.stripLineEnd` to all lines + * end characters, i.e., apply `.stripLineEnd` to all lines * returned by `linesWithSeparators`. */ def lines: Iterator[String] = linesWithSeparators map (line => new WrappedString(line).stripLineEnd) /** Return all lines in this string in an iterator, excluding trailing line - * end characters, i.e. apply `.stripLineEnd` to all lines + * end characters, i.e., apply `.stripLineEnd` to all lines * returned by `linesWithSeparators`. */ @deprecated("Use `lines` instead.","2.11.0") diff --git a/src/library/scala/concurrent/duration/Deadline.scala b/src/library/scala/concurrent/duration/Deadline.scala index 61cbe4753072..a25a4786027f 100644 --- a/src/library/scala/concurrent/duration/Deadline.scala +++ b/src/library/scala/concurrent/duration/Deadline.scala @@ -25,15 +25,15 @@ package scala.concurrent.duration */ case class Deadline private (time: FiniteDuration) extends Ordered[Deadline] { /** - * Return a deadline advanced (i.e. moved into the future) by the given duration. + * Return a deadline advanced (i.e., moved into the future) by the given duration. */ def +(other: FiniteDuration): Deadline = copy(time = time + other) /** - * Return a deadline moved backwards (i.e. towards the past) by the given duration. + * Return a deadline moved backwards (i.e., towards the past) by the given duration. */ def -(other: FiniteDuration): Deadline = copy(time = time - other) /** - * Calculate time difference between this and the other deadline, where the result is directed (i.e. may be negative). + * Calculate time difference between this and the other deadline, where the result is directed (i.e., may be negative). */ def -(other: Deadline): FiniteDuration = time - other.time /** diff --git a/src/library/scala/math/BigDecimal.scala b/src/library/scala/math/BigDecimal.scala index bcbed645a750..5a81710986b5 100644 --- a/src/library/scala/math/BigDecimal.scala +++ b/src/library/scala/math/BigDecimal.scala @@ -617,10 +617,10 @@ extends ScalaNumber with ScalaNumericConversions with Serializable { */ def abs: BigDecimal = if (signum < 0) unary_- else this - /** Returns the sign of this BigDecimal, i.e. + /** Returns the sign of this BigDecimal; * -1 if it is less than 0, - * +1 if it is greater than 0 - * 0 if it is equal to 0 + * +1 if it is greater than 0, + * 0 if it is equal to 0. */ def signum: Int = this.bigDecimal.signum() diff --git a/src/library/scala/math/BigInt.scala b/src/library/scala/math/BigInt.scala index 689fc0c3e1a5..abc7371d9fb0 100644 --- a/src/library/scala/math/BigInt.scala +++ b/src/library/scala/math/BigInt.scala @@ -282,10 +282,10 @@ final class BigInt(val bigInteger: BigInteger) extends ScalaNumber with ScalaNum */ def abs: BigInt = new BigInt(this.bigInteger.abs()) - /** Returns the sign of this BigInt, i.e. + /** Returns the sign of this BigInt; * -1 if it is less than 0, - * +1 if it is greater than 0 - * 0 if it is equal to 0 + * +1 if it is greater than 0, + * 0 if it is equal to 0. */ def signum: Int = this.bigInteger.signum() diff --git a/src/library/scala/runtime/ScalaRunTime.scala b/src/library/scala/runtime/ScalaRunTime.scala index 5fb24f2a366a..f50059ce5488 100644 --- a/src/library/scala/runtime/ScalaRunTime.scala +++ b/src/library/scala/runtime/ScalaRunTime.scala @@ -62,7 +62,7 @@ object ScalaRunTime { } /** Return the class object representing an unboxed value type, - * e.g. classOf[int], not classOf[java.lang.Integer]. The compiler + * e.g., classOf[int], not classOf[java.lang.Integer]. The compiler * rewrites expressions like 5.getClass to come here. */ def anyValClass[T <: AnyVal : ClassTag](value: T): jClass[T] = diff --git a/src/library/scala/sys/Prop.scala b/src/library/scala/sys/Prop.scala index 04c7b5108c16..17ae8cb69ca1 100644 --- a/src/library/scala/sys/Prop.scala +++ b/src/library/scala/sys/Prop.scala @@ -20,7 +20,7 @@ package sys * @since 2.9 */ trait Prop[+T] { - /** The full name of the property, e.g. "java.awt.headless". + /** The full name of the property, e.g., "java.awt.headless". */ def key: String diff --git a/src/library/scala/util/Properties.scala b/src/library/scala/util/Properties.scala index 2daa4de9a6df..8835730d9571 100644 --- a/src/library/scala/util/Properties.scala +++ b/src/library/scala/util/Properties.scala @@ -107,7 +107,7 @@ private[scala] trait PropertiesTrait { val versionString = "version " + scalaPropOrElse("version.number", "(unknown)") val copyrightString = scalaPropOrElse("copyright.string", "Copyright 2002-2013, LAMP/EPFL") - /** This is the encoding to use reading in source files, overridden with -encoding + /** This is the encoding to use reading in source files, overridden with -encoding. * Note that it uses "prop" i.e. looks in the scala jar, not the system properties. */ def sourceEncoding = scalaPropOrElse("file.encoding", "UTF-8") diff --git a/src/library/scala/util/matching/Regex.scala b/src/library/scala/util/matching/Regex.scala index f35ea566bab0..2e1bfb02e4b3 100644 --- a/src/library/scala/util/matching/Regex.scala +++ b/src/library/scala/util/matching/Regex.scala @@ -543,7 +543,7 @@ object Regex { if (start(i) >= 0) source.subSequence(start(i), end(i)).toString else null - /** All matched subgroups, i.e. not including group(0) */ + /** All matched subgroups, i.e., not including group(0) */ def subgroups: List[String] = (1 to groupCount).toList map group /** The char sequence before first character of match, From 40beefbb750d326a5ae71ed852c58dc9a31d7e17 Mon Sep 17 00:00:00 2001 From: Masato Sogame Date: Mon, 14 Jul 2014 20:20:51 +0900 Subject: [PATCH 480/826] [backport] Update javadoc tag to new scaladoc tags. (cherry picked from commit 68b16a0992877b4ebbb7c967804edbb72c05ceb5) --- .../scala/tools/nsc/ast/DocComments.scala | 9 +++++++- .../scala/tools/nsc/doc/ScaladocGlobal.scala | 1 + .../nsc/doc/base/CommentFactoryBase.scala | 22 +++++++++---------- 3 files changed, 20 insertions(+), 12 deletions(-) diff --git a/src/compiler/scala/tools/nsc/ast/DocComments.scala b/src/compiler/scala/tools/nsc/ast/DocComments.scala index 6d9b41ec45b7..02a199f7ac47 100755 --- a/src/compiler/scala/tools/nsc/ast/DocComments.scala +++ b/src/compiler/scala/tools/nsc/ast/DocComments.scala @@ -59,14 +59,21 @@ trait DocComments { self: Global => comment.defineVariables(sym) } + + def replaceInheritDocToInheritdoc(docStr: String):String = { + docStr.replaceAll("""\{@inheritDoc\p{Zs}*\}""", "@inheritdoc") + } + /** The raw doc comment of symbol `sym`, minus usecase and define sections, augmented by * missing sections of an inherited doc comment. * If a symbol does not have a doc comment but some overridden version of it does, * the doc comment of the overridden version is copied instead. */ def cookedDocComment(sym: Symbol, docStr: String = ""): String = cookedDocComments.getOrElseUpdate(sym, { - val ownComment = if (docStr.length == 0) docComments get sym map (_.template) getOrElse "" + var ownComment = if (docStr.length == 0) docComments get sym map (_.template) getOrElse "" else DocComment(docStr).template + ownComment = replaceInheritDocToInheritdoc(ownComment) + superComment(sym) match { case None => if (ownComment.indexOf("@inheritdoc") != -1) diff --git a/src/scaladoc/scala/tools/nsc/doc/ScaladocGlobal.scala b/src/scaladoc/scala/tools/nsc/doc/ScaladocGlobal.scala index 2ea3a0eb7ca1..4b40d25c1780 100644 --- a/src/scaladoc/scala/tools/nsc/doc/ScaladocGlobal.scala +++ b/src/scaladoc/scala/tools/nsc/doc/ScaladocGlobal.scala @@ -11,6 +11,7 @@ import reporters.Reporter import typechecker.Analyzer import scala.reflect.internal.util.{ BatchSourceFile, RangePosition } + trait ScaladocGlobalTrait extends Global { outer => diff --git a/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala b/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala index 19cc27b40b0d..d5e2f9a2c4d5 100755 --- a/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala +++ b/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala @@ -131,18 +131,19 @@ trait CommentFactoryBase { this: MemberLookupBase => /** Javadoc tags that should be replaced by something useful, such as wiki * syntax, or that should be dropped. */ private val JavadocTags = - new Regex("""\{\@(code|docRoot|inheritDoc|link|linkplain|literal|value)([^}]*)\}""") + new Regex("""\{\@(code|docRoot|linkplain|link|literal|value)\p{Zs}*([^}]*)\}""") /** Maps a javadoc tag to a useful wiki replacement, or an empty string if it cannot be salvaged. */ - private def javadocReplacement(mtch: Regex.Match): String = mtch.group(1) match { - case "code" => "`" + mtch.group(2) + "`" - case "docRoot" => "" - case "inheritDoc" => "" - case "link" => "`" + mtch.group(2) + "`" - case "linkplain" => "`" + mtch.group(2) + "`" - case "literal" => mtch.group(2) - case "value" => "`" + mtch.group(2) + "`" - case _ => "" + private def javadocReplacement(mtch: Regex.Match): String = { + mtch.group(1) match { + case "code" => "" + mtch.group(2) + "" + case "docRoot" => "" + case "link" => "`[[" + mtch.group(2) + "]]`" + case "linkplain" => "[[" + mtch.group(2) + "]]" + case "literal" => "`" + mtch.group(2) + "`" + case "value" => "`" + mtch.group(2) + "`" + case _ => "" + } } /** Safe HTML tags that can be kept. */ @@ -680,7 +681,6 @@ trait CommentFactoryBase { this: MemberLookupBase => jump("[[") val parens = 2 + repeatJump('[') val stop = "]" * parens - //println("link with " + parens + " matching parens") val target = readUntil { check(stop) || check(" ") } val title = if (!check(stop)) Some({ From 771724494d4a7e73542c04e8e0b50523745fb7a8 Mon Sep 17 00:00:00 2001 From: Masato Sogame Date: Sat, 12 Jul 2014 23:47:10 +0900 Subject: [PATCH 481/826] [backport] Rewrite explanation of doc-source-url option more clearly, and fix encoding to show euro-sign correctly. (cherry picked from commit 13054daa658484df30b71447dbe684f475537252) --- src/scaladoc/scala/tools/nsc/doc/Settings.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scaladoc/scala/tools/nsc/doc/Settings.scala b/src/scaladoc/scala/tools/nsc/doc/Settings.scala index a8e1dee4a048..44683f17559c 100644 --- a/src/scaladoc/scala/tools/nsc/doc/Settings.scala +++ b/src/scaladoc/scala/tools/nsc/doc/Settings.scala @@ -66,7 +66,7 @@ class Settings(error: String => Unit, val printMsg: String => Unit = println(_)) val docsourceurl = StringSetting ( "-doc-source-url", "url", - "A URL pattern used to build links to template sources; use variables, for example: ?{TPL_NAME} ('Seq'), ?{TPL_OWNER} ('scala.collection'), ?{FILE_PATH} ('scala/collection/Seq')", + s"A URL pattern used to link to the source file; the following variables are available: €{TPL_NAME}, €{TPL_OWNER} and respectively €{FILE_PATH}. For example, for `scala.collection.Seq`, the variables will be expanded to `Seq`, `scala.collection` and respectively `scala/collection/Seq` (without the backquotes). To obtain a relative path for €{FILE_PATH} instead of an absolute one, use the ${sourcepath.name} setting.", "" ) From 0270972b9f70d107dff393081dc48c877be1f161 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 12 Aug 2014 10:57:42 +0200 Subject: [PATCH 482/826] test for InnerClass and EnclosingMethod attributes Some parts of the test assert (current) buggy behavior. This is marked in the test file with TODO. It will be fixed in later work on the backend. --- .../jvm/innerClassAttribute/Classes_1.scala | 99 +++++++++ .../jvm/innerClassAttribute/JavaAnnot_1.java | 3 + test/files/jvm/innerClassAttribute/Test.scala | 208 ++++++++++++++++++ 3 files changed, 310 insertions(+) create mode 100644 test/files/jvm/innerClassAttribute/Classes_1.scala create mode 100644 test/files/jvm/innerClassAttribute/JavaAnnot_1.java create mode 100644 test/files/jvm/innerClassAttribute/Test.scala diff --git a/test/files/jvm/innerClassAttribute/Classes_1.scala b/test/files/jvm/innerClassAttribute/Classes_1.scala new file mode 100644 index 000000000000..0875d9160c91 --- /dev/null +++ b/test/files/jvm/innerClassAttribute/Classes_1.scala @@ -0,0 +1,99 @@ +class A1 { + class B +} + +class A2 { + object B +} + +object A3 { + class B1 + object B2 +} + +class A4 { + def f(l: List[Int]): List[Int] = { + l map (_ + 1) + } +} + +class A5 { + def f(): Object = { + object B + B + } +} + +trait A6 { + def hui = -6 + trait TT +} + +class A7 extends A6 + +abstract class A8 extends A6 { + def fish: TT +} + +class A9 { + class brick extends annotation.StaticAnnotation +} + +class A10 { + val a9 = new A9() + // there's no reference to brick in the bytecode (only in the pickle), so there's no InnerClass attribute for it. + @a9.brick def f = -7 +} + +class A11 { + @JavaAnnot_1.Ann def f = -8 +} + +object A12 { + object B { + class C + } +} + +class A13 { + def oak: A12.B.C = new A12.B.C +} + +class A14 { + def f = { + val x: Object = { + class K + new K + } + x + } + def g = { + val x: Object = new A6 { } + } +} + +object A15 { + def f = { + class B { // static (does not have an outer pointer) + class C // non-static + } + } +} + +class A16 { + val x: A6 = { + class U extends A6 + new A6 { } + } + + { + class V extends A6 + new A6 { } + } +} + +class A17 { + object B { + class C // not static, has an outer pointer. + } +} diff --git a/test/files/jvm/innerClassAttribute/JavaAnnot_1.java b/test/files/jvm/innerClassAttribute/JavaAnnot_1.java new file mode 100644 index 000000000000..27c4d4e5d359 --- /dev/null +++ b/test/files/jvm/innerClassAttribute/JavaAnnot_1.java @@ -0,0 +1,3 @@ +public class JavaAnnot_1 { + public static @interface Ann {} +} diff --git a/test/files/jvm/innerClassAttribute/Test.scala b/test/files/jvm/innerClassAttribute/Test.scala new file mode 100644 index 000000000000..6cf60ab92df5 --- /dev/null +++ b/test/files/jvm/innerClassAttribute/Test.scala @@ -0,0 +1,208 @@ +import scala.tools.partest.BytecodeTest +import scala.tools.asm +import asm.tree.{ClassNode, InnerClassNode} +import asm.{Opcodes => Flags} +import scala.collection.JavaConverters._ + +object Test extends BytecodeTest { + def assertSame(a: Any, b: Any) = { + assert(a == b, s"\na: $a\nb: $b") + } + + val publicStatic = Flags.ACC_PUBLIC | Flags.ACC_STATIC + val publicAbstractInterface = Flags.ACC_PUBLIC | Flags.ACC_ABSTRACT | Flags.ACC_INTERFACE + + def innerClassNodes(className: String): List[InnerClassNode] = { + loadClassNode(className).innerClasses.asScala.toList.sortBy(_.name) + } + + final case class EnclosingMethod(name: String, descriptor: String, outerClass: String) + def enclosingMethod(className: String) = { + val n = loadClassNode(className) + EnclosingMethod(n.outerMethod, n.outerMethodDesc, n.outerClass) + } + + def assertMember(node: InnerClassNode, outer: String, inner: String, name: Option[String] = None, flags: Int = Flags.ACC_PUBLIC) = { + assertSame(node.name, name.getOrElse(s"$outer$$$inner")) + assertSame(node.outerName, outer) + assertSame(node.innerName, inner) + assertSame(node.access, flags) + } + + def assertAnonymous(node: InnerClassNode, name: String, flags: Int = Flags.ACC_PUBLIC | Flags.ACC_FINAL) = { + assertSame(node.name, name) + assertSame(node.outerName, null) + assertSame(node.innerName, null) + assertSame(node.access, flags) + } + + def assertLocal(node: InnerClassNode, name: String, inner: String, flags: Int = Flags.ACC_PUBLIC) = { + assertSame(node.name, name) + assertSame(node.outerName, null) + assertSame(node.innerName, inner) + assertSame(node.access, flags) + } + + def assertEnclosingMethod(enclosingMethod: EnclosingMethod, outerClass: String, name: String, descriptor: String) = { + assertSame(enclosingMethod.outerClass, outerClass) + assertSame(enclosingMethod.name, name) + assertSame(enclosingMethod.descriptor, descriptor) + } + + def testA1() = { + val List(b1) = innerClassNodes("A1") + assertMember(b1, "A1", "B") + val List(b2) = innerClassNodes("A1$B") + assertMember(b2, "A1", "B") + } + + def testA2() = { + val List(b1) = innerClassNodes("A2") + assertMember(b1, "A2", "B$") + val List(b2) = innerClassNodes("A2$B$") + assertMember(b2, "A2", "B$") + } + + def testA3() = { + def t(c: String) = { + val List(b1, b2) = innerClassNodes(c) + // the outer class for classes nested inside top-level modules is not the module class, but the mirror class. + // this is a hack for java interop, handled in the backend. see BTypes.scala, comment on "Java Compatibility". + assertMember(b1, "A3", "B1", flags = publicStatic) + assertMember(b2, "A3", "B2$", flags = publicStatic) + } + t("A3$") + // the mirror class has the same inner class attributes as the module + // class (added when the mirror is created in the backend) + t("A3") + } + + def testA4() = { + val List(an1) = innerClassNodes("A4") + assertAnonymous(an1, "A4$$anonfun$f$1") + val List(an2) = innerClassNodes("A4$$anonfun$f$1") + assertAnonymous(an2, "A4$$anonfun$f$1") + assertEnclosingMethod( + enclosingMethod("A4$$anonfun$f$1"), + "A4", "f", "(Lscala/collection/immutable/List;)Lscala/collection/immutable/List;") + } + + def testA5() = { + val List(b1) = innerClassNodes("A5") + assertLocal(b1, "A5$B$2$", "B$2$") + val List(b2) = innerClassNodes("A5$B$2$") + assertLocal(b2, "A5$B$2$", "B$2$") + assertEnclosingMethod( + enclosingMethod("A5$B$2$"), + "A5", "f", "()Ljava/lang/Object;") + } + + def testA6() = { + val List(tt1) = innerClassNodes("A6") + assertMember(tt1, "A6", "TT", flags = publicAbstractInterface) + val List() = innerClassNodes("A6$class") + val List(tt2) = innerClassNodes("A6$TT") + assertMember(tt2, "A6", "TT", flags = publicAbstractInterface) + } + + def testA7() = { + val List() = innerClassNodes("A7") + } + + def testA8() = { + val List(tt) = innerClassNodes("A8") + assertMember(tt, "A6", "TT", flags = publicAbstractInterface) + } + + def testA10() = { + val List() = innerClassNodes("A10") + } + + def testA11() = { + val List(ann) = innerClassNodes("A11") + // in the java class file, the INNERCLASS attribute has more flags (public | static | abstract | interface | annotation) + // the scala compiler has its own interpretation of java annotations ant their flags.. it only emits publicStatic. + assertMember(ann, "JavaAnnot_1", "Ann", flags = publicStatic) + } + + def testA13() = { + val List(b, c) = innerClassNodes("A13") + assertMember(b, "A12", "B$", flags = publicStatic) + assertMember(c, "A12$B$", "C", name = Some("A12$B$C"), flags = publicStatic) + } + + def testA14() = { + val List(anon, k) = innerClassNodes("A14") + + assertLocal(k, "A14$K$1", "K$1") + assertEnclosingMethod( + enclosingMethod("A14$K$1"), + "A14", "f", "()Ljava/lang/Object;") + + assertAnonymous(anon, "A14$$anon$1") + assertEnclosingMethod( + enclosingMethod("A14$$anon$1"), + "A14", "g", "()V") + } + + def testA15() = { + val List(b) = innerClassNodes("A15") + assertLocal(b, "A15$B$3", "B$3", flags = publicStatic) + + val List(_, c) = innerClassNodes("A15$B$3") + // TODO this is a bug in the backend, C should be a member. Instead, its outerClass is null + // assertMember(c, "A15$B$3", "C") + assertLocal(c, "A15$B$3$C", "C") + } + + def testA16() = { + val List(anon1, anon2, u, v) = innerClassNodes("A16") + // TODO there's a bug in the backend: anon$2 has outerClass A16, but anonymous classes should have outerClass null + // assertAnonymous(anon1, "A16$$anon$2") + assertMember(anon1, "A16", null, name = Some("A16$$anon$2"), flags = Flags.ACC_PUBLIC | Flags.ACC_FINAL) + assertAnonymous(anon2, "A16$$anon$3") + // TODO this is a bug in the backend, U should not be a member, its outerClass should be null + // assertLocal(u, "A16$U$1", "U$1") + assertMember(u, "A16", "U$1") + assertLocal(v, "A16$V$1", "V$1") + + assertEnclosingMethod( + enclosingMethod("A16$$anon$2"), + "A16", "", "()V") + assertEnclosingMethod( + enclosingMethod("A16$$anon$3"), + "A16", "", "()V") + // TODO this is a bug, there should be an enclosingMethod attribute in U + // assertEnclosingMethod( + // enclosingMethod("A16$U$1"), + // "A16", "", "()V") + assertEnclosingMethod( + enclosingMethod("A16$V$1"), + "A16", "", "()V") + } + + def testA17() = { + val List(b, c) = innerClassNodes("A17$B$") + assertMember(b, "A17", "B$") + // TODO this is a bug, should not be static. + assertMember(c, "A17$B$", "C", name = Some("A17$B$C"), flags = publicStatic) // (should be) not static, has an outer pointer. + } + + def show(): Unit = { + testA1() + testA2() + testA3() + testA4() + testA5() + testA6() + testA7() + testA8() + testA10() + testA11() + testA13() + testA14() + testA15() + testA16() + testA17() + } +} From 756e551b30461b548ea59e99562634775b7ebd74 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Thu, 31 Jul 2014 17:52:13 +0200 Subject: [PATCH 483/826] SI-5691 lint warning when a type parameter shadows an existing type. This adds a new lint warning for when a class/method/type-member's type parameter shadows an existing type: `-Xlint:type-parameter-shadow`. It excludes type parameters of synthetic methods (the user can't rename or remove those anyway), otherwise, for example, every case class triggers the warning. Also fixes a test that contained wrong java sources (that didn't even compile...), discovered thanks to the warning. --- This kind of errors shows up every now and then on the mailing-list, on stackoverflow, etc. so maybe a warning would be useful. I was afraid this would yield too many warnings for libraries that are heavy on type parameters, but no: running this on scalaz and shapeless HEAD (`v7.1.0-RC1-41-g1cc0a96` and `v2.0.0-M1-225-g78426a0` respectively) yields 44 warnings. None of them are false positives; they usually come from: - scalaz loving using `A` as type parameter, even several levels deep of parametrized classes/methods - or calling a type parameter that will hold a map `Map`, or similar, thus shadowing an existing type --- .../scala/tools/nsc/settings/Warnings.scala | 3 +++ .../nsc/typechecker/TypeDiagnostics.scala | 17 ++++++++++++ .../scala/tools/nsc/typechecker/Typers.scala | 6 +++++ test/files/neg/forgot-interpolator.scala | 4 +-- test/files/neg/t4851.check | 4 +-- test/files/neg/t4851/J2.java | 4 +-- test/files/neg/t5691.check | 24 +++++++++++++++++ test/files/neg/t5691.flags | 1 + test/files/neg/t5691.scala | 27 +++++++++++++++++++ test/files/neg/t6675b.scala | 2 +- 10 files changed, 85 insertions(+), 7 deletions(-) create mode 100644 test/files/neg/t5691.check create mode 100644 test/files/neg/t5691.flags create mode 100644 test/files/neg/t5691.scala diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala index bec068b56a17..4c3763330190 100644 --- a/src/compiler/scala/tools/nsc/settings/Warnings.scala +++ b/src/compiler/scala/tools/nsc/settings/Warnings.scala @@ -38,6 +38,7 @@ trait Warnings { warnMissingInterpolator, warnDocDetached, warnPrivateShadow, + warnTypeParameterShadow, warnPolyImplicitOverload, warnOptionImplicit, warnDelayedInit, @@ -83,6 +84,8 @@ trait Warnings { "A ScalaDoc comment appears to be detached from its element.") val warnPrivateShadow = lintflag("private-shadow", "A private field (or class parameter) shadows a superclass field.") + val warnTypeParameterShadow = lintflag("type-parameter-shadow", + "A local type parameter shadows a type already in scope.") val warnPolyImplicitOverload = lintflag("poly-implicit-overload", "Parameterized overloaded implicit methods are not visible as view bounds") val warnOptionImplicit = lintflag("option-implicit", diff --git a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala index 7440f69e9383..d18348f51e2d 100644 --- a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala +++ b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala @@ -600,6 +600,23 @@ trait TypeDiagnostics { ) } + // warn about class/method/type-members' type parameters that shadow types already in scope + def warnTypeParameterShadow(tparams: List[TypeDef], sym: Symbol): Unit = + if (settings.warnTypeParameterShadow && !isPastTyper && !sym.isSynthetic) { + def enclClassOrMethodOrTypeMember(c: Context): Context = + if (!c.owner.exists || c.owner.isClass || c.owner.isMethod || (c.owner.isType && !c.owner.isParameter)) c + else enclClassOrMethodOrTypeMember(c.outer) + + val tt = tparams.filter(_.name != typeNames.WILDCARD).foreach { tp => + // we don't care about type params shadowing other type params in the same declaration + enclClassOrMethodOrTypeMember(context).outer.lookupSymbol(tp.name, s => s != tp.symbol && s.hasRawInfo && reallyExists(s)) match { + case LookupSucceeded(_, sym2) => context.warning(tp.pos, + s"type parameter ${tp.name} defined in $sym shadows $sym2 defined in ${sym2.owner}. You may want to rename your type parameter, or possibly remove it.") + case _ => + } + } + } + /** Report a type error. * * @param pos The position where to report the error diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala index 70f44c4fc60a..31a15063bdc3 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala @@ -1749,6 +1749,8 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper |you want, you must write the annotation class in Java.""".stripMargin) } + warnTypeParameterShadow(tparams1, clazz) + if (!isPastTyper) { for (ann <- clazz.getAnnotation(DeprecatedAttr)) { val m = companionSymbolOf(clazz, context) @@ -2151,6 +2153,8 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper val tparams1 = ddef.tparams mapConserve typedTypeDef val vparamss1 = ddef.vparamss mapConserve (_ mapConserve typedValDef) + warnTypeParameterShadow(tparams1, meth) + meth.annotations.map(_.completeInfo()) for (vparams1 <- vparamss1; vparam1 <- vparams1 dropRight 1) @@ -2227,6 +2231,8 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper val typedMods = typedModifiers(tdef.mods) tdef.symbol.annotations.map(_.completeInfo()) + warnTypeParameterShadow(tparams1, tdef.symbol) + // @specialized should not be pickled when compiling with -no-specialize if (settings.nospecialization && currentRun.compiles(tdef.symbol)) { tdef.symbol.removeAnnotation(definitions.SpecializedClass) diff --git a/test/files/neg/forgot-interpolator.scala b/test/files/neg/forgot-interpolator.scala index a53054d89014..ca1ac308211f 100644 --- a/test/files/neg/forgot-interpolator.scala +++ b/test/files/neg/forgot-interpolator.scala @@ -54,8 +54,8 @@ package test { } } import annotation._ - @implicitNotFound("No Z in ${A}") // no warn - class Z[A] + @implicitNotFound("No Z in ${T}") // no warn + class Z[T] } diff --git a/test/files/neg/t4851.check b/test/files/neg/t4851.check index 132dd91b504a..d5711a889bf4 100644 --- a/test/files/neg/t4851.check +++ b/test/files/neg/t4851.check @@ -29,13 +29,13 @@ S.scala:7: warning: Adapting argument list by creating a 3-tuple: this may not b val y2 = new Some(1, 2, 3) ^ S.scala:9: warning: Adaptation of argument list by inserting () has been deprecated: this is unlikely to be what you want. - signature: J2[T](x: T): J2[T] + signature: J2(x: T): J2[T] given arguments: after adaptation: new J2((): Unit) val z1 = new J2 ^ S.scala:10: warning: Adaptation of argument list by inserting () has been deprecated: this is unlikely to be what you want. - signature: J2[T](x: T): J2[T] + signature: J2(x: T): J2[T] given arguments: after adaptation: new J2((): Unit) val z2 = new J2() diff --git a/test/files/neg/t4851/J2.java b/test/files/neg/t4851/J2.java index 82954d94893a..a90f48e26968 100644 --- a/test/files/neg/t4851/J2.java +++ b/test/files/neg/t4851/J2.java @@ -1,11 +1,11 @@ public class J2 { T x; - public J(T x) { + public J2(T x) { this.x = x; } public String toString() { return "J2:" + x.getClass(); } -} \ No newline at end of file +} diff --git a/test/files/neg/t5691.check b/test/files/neg/t5691.check new file mode 100644 index 000000000000..a51ca98a1089 --- /dev/null +++ b/test/files/neg/t5691.check @@ -0,0 +1,24 @@ +t5691.scala:7: warning: type parameter D defined in method foobar shadows trait D defined in class B. You may want to rename your type parameter, or possibly remove it. + def foobar[D](in: D) = in.toString + ^ +t5691.scala:10: warning: type parameter D defined in type MySeq shadows trait D defined in class B. You may want to rename your type parameter, or possibly remove it. + type MySeq[D] = Seq[D] + ^ +t5691.scala:15: warning: type parameter T defined in method bar shadows type T defined in class Foo. You may want to rename your type parameter, or possibly remove it. + def bar[T](w: T) = w.toString + ^ +t5691.scala:13: warning: type parameter T defined in class Foo shadows type T defined in class B. You may want to rename your type parameter, or possibly remove it. + class Foo[T](t: T) { + ^ +t5691.scala:19: warning: type parameter List defined in type M shadows type List defined in package object scala. You may want to rename your type parameter, or possibly remove it. + class C[M[List[_]]] + ^ +t5691.scala:20: warning: type parameter List defined in type M shadows type List defined in package object scala. You may want to rename your type parameter, or possibly remove it. + type E[M[List[_]]] = Int + ^ +t5691.scala:21: warning: type parameter List defined in type M shadows type List defined in package object scala. You may want to rename your type parameter, or possibly remove it. + def foo[N[M[List[_]]]] = ??? + ^ +error: No warnings can be incurred under -Xfatal-warnings. +7 warnings found +one error found diff --git a/test/files/neg/t5691.flags b/test/files/neg/t5691.flags new file mode 100644 index 000000000000..0e09b8575b42 --- /dev/null +++ b/test/files/neg/t5691.flags @@ -0,0 +1 @@ +-Xlint:type-parameter-shadow -language:higherKinds -Xfatal-warnings diff --git a/test/files/neg/t5691.scala b/test/files/neg/t5691.scala new file mode 100644 index 000000000000..e6a9bdc16a61 --- /dev/null +++ b/test/files/neg/t5691.scala @@ -0,0 +1,27 @@ +class B { + + type T = Int + trait D + + // method parameter shadows some other type + def foobar[D](in: D) = in.toString + + // type member's parameter shadows some other type + type MySeq[D] = Seq[D] + + // class parameter shadows some other type + class Foo[T](t: T) { + // a type parameter shadows another type parameter + def bar[T](w: T) = w.toString + } + + // even deeply nested... + class C[M[List[_]]] + type E[M[List[_]]] = Int + def foo[N[M[List[_]]]] = ??? + + // ...but not between type parameters in the same list + class F[A, M[L[A]]] // no warning! + type G[A, M[L[A]]] = Int // no warning! + def bar[A, N[M[L[A]]]] = ??? // no warning! +} diff --git a/test/files/neg/t6675b.scala b/test/files/neg/t6675b.scala index c86c9c3955b3..da27e1b91f7b 100644 --- a/test/files/neg/t6675b.scala +++ b/test/files/neg/t6675b.scala @@ -13,7 +13,7 @@ object NativelyTwo { } -class A { +class E { def f1 = (Left((0, 0)): Either[(Int, Int), (Int, Int)]) match { case LeftOrRight(a) => a } // warn def f2 = (Left((0, 0)): Either[(Int, Int), (Int, Int)]) match { case LeftOrRight((a, b)) => a } // no warn def f3 = (Left((0, 0)): Either[(Int, Int), (Int, Int)]) match { case LeftOrRight((a, b, c)) => a } // fail From fceae7084cc196e37bb8cf9efa96b994c0d73738 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Mon, 28 Apr 2014 19:21:00 +0200 Subject: [PATCH 484/826] [backport] SI-7710 fix memory performance of RegexParsers in jdk7u6+ Backport of scala/scala-parser-combinators@91584dc. --- Starting with 1.7.0_06 [1], String.substring no longer reuses the internal char array of the String but make a copy instead. Since we call subSequence twice for *every* input character, this results in horrible parse performance and GC. With the benchmark from the (duplicate) ticket SI-8542, I get: BEFORE: parseAll(new StringReader(String)) For 100 items: 49 ms For 500 items: 97 ms For 1000 items: 155 ms For 5000 items: 113 ms For 10000 items: 188 ms For 50000 items: 1437 ms === parseAll(String) For 100 items: 4 ms For 500 items: 67 ms For 1000 items: 372 ms For 5000 items: 5693 ms For 10000 items: 23126 ms For 50000 items: 657665 ms AFTER: parseAll(new StringReader(String)) For 100 items: 43 ms For 500 items: 118 ms For 1000 items: 217 ms For 5000 items: 192 ms For 10000 items: 196 ms For 50000 items: 1424 ms === parseAll(String) For 100 items: 2 ms For 500 items: 8 ms For 1000 items: 16 ms For 5000 items: 79 ms For 10000 items: 161 ms For 50000 items: 636 ms [1] http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6924259 --- bincompat-forward.whitelist.conf | 6 +++- .../parsing/combinator/RegexParsers.scala | 4 +-- .../util/parsing/combinator/SubSequence.scala | 32 +++++++++++++++++++ 3 files changed, 39 insertions(+), 3 deletions(-) create mode 100644 src/library/scala/util/parsing/combinator/SubSequence.scala diff --git a/bincompat-forward.whitelist.conf b/bincompat-forward.whitelist.conf index 7879ecfd841a..d8a91f3ae857 100644 --- a/bincompat-forward.whitelist.conf +++ b/bincompat-forward.whitelist.conf @@ -177,7 +177,11 @@ filter { { matchName="scala.reflect.runtime.JavaMirrors#JavaMirror.scala$reflect$runtime$JavaMirrors$JavaMirror$$followStatic" problemName=MissingMethodProblem + }, + { + # only accessible from util.parsing.combinator package + matchName="scala.util.parsing.combinator.SubSequence" + problemName=MissingClassProblem } - ] } diff --git a/src/library/scala/util/parsing/combinator/RegexParsers.scala b/src/library/scala/util/parsing/combinator/RegexParsers.scala index d17d0cac8d29..5f2c07c2ef53 100644 --- a/src/library/scala/util/parsing/combinator/RegexParsers.scala +++ b/src/library/scala/util/parsing/combinator/RegexParsers.scala @@ -72,7 +72,7 @@ trait RegexParsers extends Parsers { */ protected def handleWhiteSpace(source: java.lang.CharSequence, offset: Int): Int = if (skipWhitespace) - (whiteSpace findPrefixMatchOf (source.subSequence(offset, source.length))) match { + (whiteSpace findPrefixMatchOf (new SubSequence(source, offset))) match { case Some(matched) => offset + matched.end case None => offset } @@ -106,7 +106,7 @@ trait RegexParsers extends Parsers { val source = in.source val offset = in.offset val start = handleWhiteSpace(source, offset) - (r findPrefixMatchOf (source.subSequence(start, source.length))) match { + (r findPrefixMatchOf (new SubSequence(source, start))) match { case Some(matched) => Success(source.subSequence(start, start + matched.end).toString, in.drop(start + matched.end - offset)) diff --git a/src/library/scala/util/parsing/combinator/SubSequence.scala b/src/library/scala/util/parsing/combinator/SubSequence.scala new file mode 100644 index 000000000000..79c8acac0f83 --- /dev/null +++ b/src/library/scala/util/parsing/combinator/SubSequence.scala @@ -0,0 +1,32 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2006-2013, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + + +package scala +package util.parsing.combinator + +// A shallow wrapper over another CharSequence (usually a String) +// +// See SI-7710: in jdk7u6 String.subSequence stopped sharing the char array of the original +// string and began copying it. +// RegexParsers calls subSequence twice per input character: that's a lot of array copying! +private[combinator] class SubSequence(s: CharSequence, start: Int, val length: Int) extends CharSequence { + def this(s: CharSequence, start: Int) = this(s, start, s.length - start) + + def charAt(i: Int) = + if (i >= 0 && i < length) s.charAt(start + i) else throw new IndexOutOfBoundsException(s"index: $i, length: $length") + + def subSequence(_start: Int, _end: Int) = { + if (_start < 0 || _end < 0 || _end > length || _start > _end) + throw new IndexOutOfBoundsException(s"start: ${_start}, end: ${_end}, length: $length") + + new SubSequence(s, start + _start, _end - _start) + } + + override def toString = s.subSequence(start, start + length).toString +} From 2e3583b3644f3acd67933b54b9b61e6d60e9b6bb Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Sat, 2 Aug 2014 14:24:54 -0700 Subject: [PATCH 485/826] SI-8512 Infer a type for f"$args" The f-interpolator gets a type param that better be Any to avoid unfortunate widenings. Hey, it worked! Unfortunately, when `Any` is inferred, `-Xlint:infer-any` takes notice. This is probably a greater problem for the f-interpolator than for quasiquotes, which are a more specialized tool. --- src/library/scala/StringContext.scala | 2 +- test/files/neg/t7848-interp-warn.flags | 2 +- test/junit/scala/StringContextTest.scala | 13 +++++++++++++ 3 files changed, 15 insertions(+), 2 deletions(-) diff --git a/src/library/scala/StringContext.scala b/src/library/scala/StringContext.scala index 2d2601c6fb8c..20a328ec8f54 100644 --- a/src/library/scala/StringContext.scala +++ b/src/library/scala/StringContext.scala @@ -163,7 +163,7 @@ case class StringContext(parts: String*) { */ // The implementation is hardwired to `scala.tools.reflect.MacroImplementations.macro_StringInterpolation_f` // Using the mechanism implemented in `scala.tools.reflect.FastTrack` - def f(args: Any*): String = macro ??? + def f[A >: Any](args: A*): String = macro ??? } object StringContext { diff --git a/test/files/neg/t7848-interp-warn.flags b/test/files/neg/t7848-interp-warn.flags index 7949c2afa212..b0d7bc25cb56 100644 --- a/test/files/neg/t7848-interp-warn.flags +++ b/test/files/neg/t7848-interp-warn.flags @@ -1 +1 @@ --Xlint -Xfatal-warnings +-Xlint:missing-interpolator -Xfatal-warnings diff --git a/test/junit/scala/StringContextTest.scala b/test/junit/scala/StringContextTest.scala index bb0e8c425263..608b82bd96f3 100644 --- a/test/junit/scala/StringContextTest.scala +++ b/test/junit/scala/StringContextTest.scala @@ -62,4 +62,17 @@ class StringContextTest { //assertEquals("????", s"????") assertEquals("!!!!", s"????") // OK to hijack core interpolator ids } + + @Test def fIf() = { + val res = f"${if (true) 2.5 else 2.5}%.2f" + assertEquals("2.50", res) + } + @Test def fIfNot() = { + val res = f"${if (false) 2.5 else 3.5}%.2f" + assertEquals("3.50", res) + } + @Test def fHeteroArgs() = { + val res = f"${3.14}%.2f rounds to ${3}%d" + assertEquals("3.14 rounds to 3", res) + } } From 606a553e12dbc1bda25939dbda3e7fcaaaa678b9 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Tue, 5 Aug 2014 23:03:41 -0700 Subject: [PATCH 486/826] SI-8512 Infer Any for the q Avoid the widening bug for q. This resolution also suffers from the inference of Any, which can trigger a warning and an anxiety attack. But that's still better than doing the wrong thing. Right? --- .../scala/reflect/api/Quasiquotes.scala | 2 +- test/files/pos/t8013.flags | 2 +- test/junit/scala/reflect/QTest.scala | 23 +++++++++++++++++++ 3 files changed, 25 insertions(+), 2 deletions(-) create mode 100644 test/junit/scala/reflect/QTest.scala diff --git a/src/reflect/scala/reflect/api/Quasiquotes.scala b/src/reflect/scala/reflect/api/Quasiquotes.scala index e905aa415371..eaae05bed541 100644 --- a/src/reflect/scala/reflect/api/Quasiquotes.scala +++ b/src/reflect/scala/reflect/api/Quasiquotes.scala @@ -13,7 +13,7 @@ trait Quasiquotes { self: Universe => protected trait api { // implementation is hardwired to `dispatch` method of `scala.tools.reflect.quasiquotes.Quasiquotes` // using the mechanism implemented in `scala.tools.reflect.FastTrack` - def apply[T](args: T*): Tree = macro ??? + def apply[A >: Any](args: A*): Tree = macro ??? def unapply(scrutinee: Any): Any = macro ??? } object q extends api diff --git a/test/files/pos/t8013.flags b/test/files/pos/t8013.flags index 954eaba3523b..3955bb67102c 100644 --- a/test/files/pos/t8013.flags +++ b/test/files/pos/t8013.flags @@ -1 +1 @@ --Xfatal-warnings -Xlint +-Xfatal-warnings -Xlint:-infer-any,_ diff --git a/test/junit/scala/reflect/QTest.scala b/test/junit/scala/reflect/QTest.scala new file mode 100644 index 000000000000..24c35dc4010f --- /dev/null +++ b/test/junit/scala/reflect/QTest.scala @@ -0,0 +1,23 @@ + +package scala.reflect + +import org.junit.Test +import org.junit.Assert._ +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 + +import scala.tools.testing.AssertUtil._ + +@RunWith(classOf[JUnit4]) +class QTest { + + import reflect.runtime._ + import universe._ + @Test def qConstantsNotHomogenized() = { + //Apply(Select(Literal(Constant(1.0)), TermName("$plus")), List(Literal(Constant(1.0)))) + val t = q"${1} + ${1.0}" + val Apply(Select(Literal(Constant(i)), TermName("$plus")), List(Literal(Constant(j)))) = t + assertEquals(1, i) + assertEquals(1.0, j) + } +} From f98c53cb03f800b3d790f3866ab90f827fd131f5 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Tue, 12 Aug 2014 09:16:26 -0700 Subject: [PATCH 487/826] SI-8787 Addressing feedback, additional periods. --- src/library/scala/util/matching/Regex.scala | 96 ++++++++++++++------- 1 file changed, 65 insertions(+), 31 deletions(-) diff --git a/src/library/scala/util/matching/Regex.scala b/src/library/scala/util/matching/Regex.scala index 3fdd256b860d..5c4e706dc1c5 100644 --- a/src/library/scala/util/matching/Regex.scala +++ b/src/library/scala/util/matching/Regex.scala @@ -62,7 +62,8 @@ import java.util.regex.{ Pattern, Matcher } * } * }}} * - * To check only whether the `Regex` matches, ignoring any groups: + * To check only whether the `Regex` matches, ignoring any groups, + * use a sequence wildcard: * * {{{ * "2004-01-20" match { @@ -70,6 +71,16 @@ import java.util.regex.{ Pattern, Matcher } * } * }}} * + * That works because a `Regex` extractor produces a sequence of strings. + * Extracting only the year from a date could also be expressed with + * a sequence wildcard: + * + * {{{ + * "2004-01-20" match { + * case date(year, _*) => s"$year was a good year for PLs." + * } + * }}} + * * In a pattern match, `Regex` normally matches the entire input. * However, an unanchored `Regex` finds the pattern anywhere * in the input. @@ -109,6 +120,13 @@ import java.util.regex.{ Pattern, Matcher } * val oldies = mi filter (_ => (mi group 1).toInt < 1960) map (s => s"$s: An oldie but goodie.") * }}} * + * Note that `findAllIn` finds matches that don't overlap. (See [[findAllIn]] for more examples.) + * + * {{{ + * val num = """(\d+)""".r + * val all = (num findAllIn "123").toList // List("123"), not List("123", "23", "3") + * }}} + * * Text replacement can be performed unconditionally or as a function of the current match: * * {{{ @@ -187,23 +205,36 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * {{{ * val p1 = "ab*c".r * val p1Matches = "abbbc" match { - * case p1() => true + * case p1() => true // no groups * case _ => false * } * val p2 = "a(b*)c".r * val p2Matches = "abbbc" match { - * case p2(_*) => true + * case p2(_*) => true // any groups * case _ => false * } * val numberOfB = "abbbc" match { - * case p2(b) => Some(b.length) + * case p2(b) => Some(b.length) // one group * case _ => None * } * val p3 = "b*".r.unanchored * val p3Matches = "abbbc" match { - * case p3() => true + * case p3() => true // find the b's * case _ => false * } + * val p4 = "a(b*)(c+)".r + * val p4Matches = "abbbcc" match { + * case p4(_*) => true // multiple groups + * case _ => false + * } + * val allGroups = "abbbcc" match { + * case p4(all @ _*) => all mkString "/" // "bbb/cc" + * case _ => "" + * } + * val cGroup = "abbbcc" match { + * case p4(_, c) => c + * case _ => "" + * } * }}} * * @param s The string to match @@ -309,7 +340,7 @@ class Regex private[matching](val pattern: Pattern, groupNames: String*) extends * }}} * * To return overlapping matches, it is possible to formulate a regular expression - * that does not consume the overlapping region. + * with lookahead (`?=`) that does not consume the overlapping region. * * {{{ * val madhatter = "(h)(?=(at[^a]+))".r @@ -580,7 +611,8 @@ object Regex { else null /** The matched string in group `i`, - * or `null` if nothing was matched */ + * or `null` if nothing was matched. + */ def group(i: Int): String = if (start(i) >= 0) source.subSequence(start(i), end(i)).toString else null @@ -589,32 +621,36 @@ object Regex { def subgroups: List[String] = (1 to groupCount).toList map group /** The char sequence before first character of match, - * or `null` if nothing was matched */ + * or `null` if nothing was matched. + */ def before: CharSequence = if (start >= 0) source.subSequence(0, start) else null /** The char sequence before first character of match in group `i`, - * or `null` if nothing was matched for that group */ + * or `null` if nothing was matched for that group. + */ def before(i: Int): CharSequence = if (start(i) >= 0) source.subSequence(0, start(i)) else null /** Returns char sequence after last character of match, - * or `null` if nothing was matched */ + * or `null` if nothing was matched. + */ def after: CharSequence = if (end >= 0) source.subSequence(end, source.length) else null /** The char sequence after last character of match in group `i`, - * or `null` if nothing was matched for that group */ + * or `null` if nothing was matched for that group. + */ def after(i: Int): CharSequence = if (end(i) >= 0) source.subSequence(end(i), source.length) else null private lazy val nameToIndex: Map[String, Int] = Map[String, Int]() ++ ("" :: groupNames.toList).zipWithIndex - /** Returns the group with given name + /** Returns the group with given name. * * @param id The group name * @return The requested group @@ -625,24 +661,22 @@ object Regex { case Some(index) => group(index) } - /** The matched string; equivalent to `matched.toString` */ + /** The matched string; equivalent to `matched.toString`. */ override def toString = matched - } - /** Provides information about a successful match. - */ + /** Provides information about a successful match. */ class Match(val source: CharSequence, private[matching] val matcher: Matcher, val groupNames: Seq[String]) extends MatchData { - /** The index of the first matched character */ + /** The index of the first matched character. */ val start = matcher.start - /** The index following the last matched character */ + /** The index following the last matched character. */ val end = matcher.end - /** The number of subgroups */ + /** The number of subgroups. */ def groupCount = matcher.groupCount private lazy val starts: Array[Int] = @@ -650,19 +684,19 @@ object Regex { private lazy val ends: Array[Int] = ((0 to groupCount) map matcher.end).toArray - /** The index of the first matched character in group `i` */ + /** The index of the first matched character in group `i`. */ def start(i: Int) = starts(i) - /** The index following the last matched character in group `i` */ + /** The index following the last matched character in group `i`. */ def end(i: Int) = ends(i) /** The match itself with matcher-dependent lazy vals forced, - * so that match is valid even once matcher is advanced + * so that match is valid even once matcher is advanced. */ def force: this.type = { starts; ends; this } } - /** An extractor object for Matches, yielding the matched string + /** An extractor object for Matches, yielding the matched string. * * This can be used to help writing replacer functions when you * are not interested in match data. For example: @@ -714,7 +748,7 @@ object Regex { nextSeen } - /** The next matched substring of `source` */ + /** The next matched substring of `source`. */ def next(): String = { if (!hasNext) throw new NoSuchElementException nextSeen = false @@ -723,28 +757,28 @@ object Regex { override def toString = super[AbstractIterator].toString - /** The index of the first matched character */ + /** The index of the first matched character. */ def start: Int = matcher.start - /** The index of the first matched character in group `i` */ + /** The index of the first matched character in group `i`. */ def start(i: Int): Int = matcher.start(i) - /** The index of the last matched character */ + /** The index of the last matched character. */ def end: Int = matcher.end - /** The index following the last matched character in group `i` */ + /** The index following the last matched character in group `i`. */ def end(i: Int): Int = matcher.end(i) - /** The number of subgroups */ + /** The number of subgroups. */ def groupCount = matcher.groupCount - /** Convert to an iterator that yields MatchData elements instead of Strings */ + /** Convert to an iterator that yields MatchData elements instead of Strings. */ def matchData: Iterator[Match] = new AbstractIterator[Match] { def hasNext = self.hasNext def next = { self.next(); new Match(source, matcher, groupNames).force } } - /** Convert to an iterator that yields MatchData elements instead of Strings and has replacement support */ + /** Convert to an iterator that yields MatchData elements instead of Strings and has replacement support. */ private[matching] def replacementData = new AbstractIterator[Match] with Replacement { def matcher = self.matcher def hasNext = self.hasNext From 131dea0810f75292da3b4fcf420d035cc59ac873 Mon Sep 17 00:00:00 2001 From: Kato Kazuyoshi Date: Tue, 12 Aug 2014 21:20:39 +0900 Subject: [PATCH 488/826] Scaladoc: the value of an id attribute must be unique within a document The value of an id attribute must be unique, according to HTML spec. --- .../tools/nsc/doc/html/page/Template.scala | 24 ++++++++++++------- .../nsc/doc/html/resource/lib/template.css | 2 +- .../nsc/doc/html/resource/lib/template.js | 20 ++++++++-------- .../scaladoc/scalacheck/HtmlFactoryTest.scala | 13 ++++++---- 4 files changed, 35 insertions(+), 24 deletions(-) diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/Template.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/Template.scala index b5a8d1ac3637..45cef88f7a30 100644 --- a/src/scaladoc/scala/tools/nsc/doc/html/page/Template.scala +++ b/src/scaladoc/scala/tools/nsc/doc/html/page/Template.scala @@ -143,7 +143,7 @@ class Template(universe: doc.Universe, generator: DiagramGenerator, tpl: DocTemp { if (tpl.linearizationTemplates.isEmpty && tpl.conversions.isEmpty) NodeSeq.Empty else { if (!tpl.linearizationTemplates.isEmpty) -
    +
    Inherited
      @@ -153,7 +153,7 @@ class Template(universe: doc.Universe, generator: DiagramGenerator, tpl: DocTemp else NodeSeq.Empty } ++ { if (!tpl.conversions.isEmpty) -
      +
      Implicitly
        { @@ -167,7 +167,7 @@ class Template(universe: doc.Universe, generator: DiagramGenerator, tpl: DocTemp
      else NodeSeq.Empty } ++ -
      +
      1. Hide All
        2. @@ -201,28 +201,28 @@ class Template(universe: doc.Universe, generator: DiagramGenerator, tpl: DocTemp } { if (absValueMembers.isEmpty) NodeSeq.Empty else -
        +

        Abstract Value Members

          { absValueMembers map (memberToHtml(_, tpl)) }
        } { if (concValueMembers.isEmpty) NodeSeq.Empty else -
        +

        { if (absValueMembers.isEmpty) "Value Members" else "Concrete Value Members" }

          { concValueMembers map (memberToHtml(_, tpl)) }
        } { if (shadowedImplicitMembers.isEmpty) NodeSeq.Empty else -
        +

        Shadowed Implicit Value Members

          { shadowedImplicitMembers map (memberToHtml(_, tpl)) }
        } { if (deprValueMembers.isEmpty) NodeSeq.Empty else -
        +

        Deprecated Value Members

          { deprValueMembers map (memberToHtml(_, tpl)) }
        @@ -287,13 +287,19 @@ class Template(universe: doc.Universe, generator: DiagramGenerator, tpl: DocTemp } def memberToHtml(mbr: MemberEntity, inTpl: DocTemplateEntity): NodeSeq = { + // Sometimes it's same, do we need signatureCompat still? + val sig = if (mbr.signature == mbr.signatureCompat) { + + } else { + + } + val memberComment = memberToCommentHtml(mbr, inTpl, isSelf = false)
      2. - - + { sig } { signature(mbr, isSelf = false) } { memberComment }
        3. diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.css b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.css index 35f66cd5df28..6d94452f3a55 100644 --- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.css +++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.css @@ -217,7 +217,7 @@ dl.attributes > dd { height: 18px; } -#values ol li:last-child { +.values ol li:last-child { margin-bottom: 5px; } diff --git a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.js b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.js index 1ebcb67f046d..5ef03848b2c7 100644 --- a/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.js +++ b/src/scaladoc/scala/tools/nsc/doc/html/resource/lib/template.js @@ -147,19 +147,19 @@ $(document).ready(function(){ filter(); }); - $("#mbrsel > div[id=ancestors] > ol > li.hideall").click(function() { + $("#mbrsel > div.ancestors > ol > li.hideall").click(function() { $("#linearization li.in").removeClass("in").addClass("out"); $("#linearization li:first").removeClass("out").addClass("in"); $("#implicits li.in").removeClass("in").addClass("out"); - if ($(this).hasClass("out") && $("#mbrsel > div[id=ancestors] > ol > li.showall").hasClass("in")) { + if ($(this).hasClass("out") && $("#mbrsel > div.ancestors > ol > li.showall").hasClass("in")) { $(this).removeClass("out").addClass("in"); - $("#mbrsel > div[id=ancestors] > ol > li.showall").removeClass("in").addClass("out"); + $("#mbrsel > div.ancestors > ol > li.showall").removeClass("in").addClass("out"); } filter(); }) - $("#mbrsel > div[id=ancestors] > ol > li.showall").click(function() { + $("#mbrsel > div.ancestors > ol > li.showall").click(function() { var filteredLinearization = $("#linearization li.out").filter(function() { return ! isHiddenClass($(this).attr("name")); @@ -172,9 +172,9 @@ $(document).ready(function(){ }); filteredImplicits.removeClass("out").addClass("in"); - if ($(this).hasClass("out") && $("#mbrsel > div[id=ancestors] > ol > li.hideall").hasClass("in")) { + if ($(this).hasClass("out") && $("#mbrsel > div.ancestors > ol > li.hideall").hasClass("in")) { $(this).removeClass("out").addClass("in"); - $("#mbrsel > div[id=ancestors] > ol > li.hideall").removeClass("in").addClass("out"); + $("#mbrsel > div.ancestors > ol > li.hideall").removeClass("in").addClass("out"); } filter(); @@ -275,7 +275,7 @@ function orderAlpha() { $("#order > ol > li.group").removeClass("in").addClass("out"); $("#template > div.parent").hide(); $("#template > div.conversion").hide(); - $("#mbrsel > div[id=ancestors]").show(); + $("#mbrsel > div.ancestors").show(); filter(); }; @@ -285,7 +285,7 @@ function orderInherit() { $("#order > ol > li.group").removeClass("in").addClass("out"); $("#template > div.parent").show(); $("#template > div.conversion").show(); - $("#mbrsel > div[id=ancestors]").hide(); + $("#mbrsel > div.ancestors").hide(); filter(); }; @@ -295,7 +295,7 @@ function orderGroup() { $("#order > ol > li.inherit").removeClass("in").addClass("out"); $("#template > div.parent").hide(); $("#template > div.conversion").hide(); - $("#mbrsel > div[id=ancestors]").show(); + $("#mbrsel > div.ancestors").show(); filter(); }; @@ -350,7 +350,7 @@ function initInherit() { } }); - $("#values > ol > li").each(function(){ + $(".values > ol > li").each(function(){ var mbr = $(this); this.mbrText = mbr.find("> .fullcomment .cmt").text(); var qualName = mbr.attr("name"); diff --git a/test/scaladoc/scalacheck/HtmlFactoryTest.scala b/test/scaladoc/scalacheck/HtmlFactoryTest.scala index ef70e0bf218d..fdc4f9527f93 100644 --- a/test/scaladoc/scalacheck/HtmlFactoryTest.scala +++ b/test/scaladoc/scalacheck/HtmlFactoryTest.scala @@ -778,6 +778,11 @@ object Test extends Properties("HtmlFactory") { linkElement \@ "href" == expectedUrl && linkElement \@ "target" == "_top" } + def assertValuesLink(memberName: String, expectedUrl: String): Boolean = { + val linkElement: NodeSeq = node \\ "div" \@ ("class", "values members") \\ "li" \@ ("name", memberName) \\ "span" \@ ("class", "permalink") \ "a" + linkElement \@ "href" == expectedUrl && linkElement \@ "target" == "_top" + } + } val files = createTemplates("SI-8144.scala") @@ -790,12 +795,12 @@ object Test extends Properties("HtmlFactory") { property("SI-8144: Members' permalink - package") = check("some/package.html") { node => ("type link" |: node.assertTypeLink("../index.html#some.package")) && - ("member: some.pack" |: node.assertMemberLink("values")("some.pack", "../index.html#some.package@pack")) + ("member: some.pack" |: node.assertValuesLink("some.pack", "../index.html#some.package@pack")) } property("SI-8144: Members' permalink - inner package") = check("some/pack/package.html") { node => ("type link" |: node.assertTypeLink("../../index.html#some.pack.package")) && - ("member: SomeType (object)" |: node.assertMemberLink("values")("some.pack.SomeType", "../../index.html#some.pack.package@SomeType")) && + ("member: SomeType (object)" |: node.assertValuesLink("some.pack.SomeType", "../../index.html#some.pack.package@SomeType")) && ("member: SomeType (class)" |: node.assertMemberLink("types")("some.pack.SomeType", "../../index.html#some.pack.package@SomeTypeextendsAnyRef")) } @@ -808,8 +813,8 @@ object Test extends Properties("HtmlFactory") { ("type link" |: node.assertTypeLink("../../index.html#some.pack.SomeType")) && ("constructor " |: node.assertMemberLink("constructors")("some.pack.SomeType#", "../../index.html#some.pack.SomeType@(arg:String):some.pack.SomeType")) && ( "member: type TypeAlias" |: node.assertMemberLink("types")("some.pack.SomeType.TypeAlias", "../../index.html#some.pack.SomeType@TypeAlias=String")) && - ( "member: def >#<():Int " |: node.assertMemberLink("values")("some.pack.SomeType#>#<", "../../index.html#some.pack.SomeType@>#<():Int")) && - ( "member: def >@<():TypeAlias " |: node.assertMemberLink("values")("some.pack.SomeType#>@<", "../../index.html#some.pack.SomeType@>@<():SomeType.this.TypeAlias")) + ( "member: def >#<():Int " |: node.assertValuesLink("some.pack.SomeType#>#<", "../../index.html#some.pack.SomeType@>#<():Int")) && + ( "member: def >@<():TypeAlias " |: node.assertValuesLink("some.pack.SomeType#>@<", "../../index.html#some.pack.SomeType@>@<():SomeType.this.TypeAlias")) } } From a16a635b647bb1cdb0759ab4ba1e794ec56d8081 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Fri, 15 Aug 2014 16:59:59 +1000 Subject: [PATCH 489/826] SI-8793 Fix patmat regression with extractors, existentials In the same vein as SI-8128 / 3e9e2c65a, revert to the 2.10.x style of determining the types of the product elements of an extractor when using `TupleN`. I believe we can discard the special casing for Option/Tuple/Seq altogether with judicious application of `repackExistential` in `unapplyMethodTypes`. That ought to also fix fix SI-8149. But I'll target that work at 2.12.x. --- .../scala/reflect/internal/Definitions.scala | 10 ++++++++-- test/files/pos/t8793.scala | 15 +++++++++++++++ 2 files changed, 23 insertions(+), 2 deletions(-) create mode 100644 test/files/pos/t8793.scala diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala index bf560a21e581..02578e20386f 100644 --- a/src/reflect/scala/reflect/internal/Definitions.scala +++ b/src/reflect/scala/reflect/internal/Definitions.scala @@ -836,12 +836,18 @@ trait Definitions extends api.StandardDefinitions { def typeOfMemberNamedHead(tp: Type) = typeArgOfBaseTypeOr(tp, SeqClass)(resultOfMatchingMethod(tp, nme.head)()) def typeOfMemberNamedApply(tp: Type) = typeArgOfBaseTypeOr(tp, SeqClass)(resultOfMatchingMethod(tp, nme.apply)(IntTpe)) def typeOfMemberNamedDrop(tp: Type) = typeArgOfBaseTypeOr(tp, SeqClass)(resultOfMatchingMethod(tp, nme.drop)(IntTpe)) - def typesOfSelectors(tp: Type) = getterMemberTypes(tp, productSelectors(tp)) + def typesOfSelectors(tp: Type) = + if (isTupleType(tp)) tp.typeArgs + else getterMemberTypes(tp, productSelectors(tp)) + // SI-8128 Still using the type argument of the base type at Seq/Option if this is an old-style (2.10 compatible) // extractor to limit exposure to regressions like the reported problem with existentials. // TODO fix the existential problem in the general case, see test/pending/pos/t8128.scala private def typeArgOfBaseTypeOr(tp: Type, baseClass: Symbol)(or: => Type): Type = (tp baseType baseClass).typeArgs match { - case x :: Nil => x + case x :: Nil => + val x1 = x + val x2 = repackExistential(x1) + x2 case _ => or } diff --git a/test/files/pos/t8793.scala b/test/files/pos/t8793.scala new file mode 100644 index 000000000000..127615567543 --- /dev/null +++ b/test/files/pos/t8793.scala @@ -0,0 +1,15 @@ +package regr + +trait F[A] + +class G(val a: F[_], val b: F[_]) + +object G { + def unapply(g: G) = Option((g.a, g.b)) +} + +object H { + def unapply(g: G) = g match { + case G(a, _) => Option(a) + } +} From bdc3ff97e7f869b393de7e4deb53535a93738ad1 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 1 Jul 2014 16:26:46 +0200 Subject: [PATCH 490/826] Set currentUnit while generating bytecode. --- src/compiler/scala/tools/nsc/Global.scala | 6 ++++-- src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 5bf0d8d9f753..08d2b89ece6b 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -395,7 +395,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) reporter.cancelled || unit.isJava && this.id > maxJavaPhase } - final def applyPhase(unit: CompilationUnit) { + final def withCurrentUnit(unit: CompilationUnit)(task: => Unit) { if ((unit ne null) && unit.exists) lastSeenSourceFile = unit.source @@ -407,7 +407,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) currentRun.currentUnit = unit if (!cancelled(unit)) { currentRun.informUnitStarting(this, unit) - apply(unit) + task } currentRun.advanceUnit() } finally { @@ -415,6 +415,8 @@ class Global(var currentSettings: Settings, var reporter: Reporter) currentRun.currentUnit = unit0 } } + + final def applyPhase(unit: CompilationUnit) = withCurrentUnit(unit)(apply(unit)) } // phaseName = "parser" diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala index 89866b7ce938..5494a827f4f2 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala @@ -130,7 +130,7 @@ abstract class GenBCode extends BCodeSyncAndTry { return } else { - try { visit(item) } + try { withCurrentUnit(item.cunit)(visit(item)) } catch { case ex: Throwable => ex.printStackTrace() From f73f026bf250e6eb3c22c2b1975d4fdc2f23eab6 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 12 Aug 2014 16:12:15 +0200 Subject: [PATCH 491/826] Remove Tracked, add type information to ClassBType Before this change, a ClassBType was just a name. The `exemplars` map stored a Tracked instance for every ClassBType. Tracked stored type information that is required later in the backend when things may run concurrently. In particular: superclass, interfaces, flags and information for emitting the InnerClass attribute. Now we put all the information stored in Tracked directly in the ClassBType. There is still one hash map: `classBTypeFromInternalNameMap` maps a JVM internal class name (e.g. "scala/Predef$") to the corresponding ClassBType. This map is used during bytecode generation, when the ASM framework computes stack map frames. In order to compute stack map frames, the ASM framework needs to be able to get the LUB of two types. The default implementation uses reflection to get type information, however that doesn't work in our case: the classes we compile are not on the classpath. So instead, the backend overwrites the method `getCommonSuperClass` of the ClassWriter. This method receives two class internal names and computes their LUB. This is done by looking up the ClassBTypes in the `classBTypeFromInternalNameMap` and invoking `jvmWiseLUB`. This commit was reviwed in https://github.com/scala/scala/pull/3855. It consists of all commits labelled [squash-after-review], squashed into one. --- .../nsc/backend/jvm/BCodeBodyBuilder.scala | 36 +- .../tools/nsc/backend/jvm/BCodeHelpers.scala | 456 ++++----- .../nsc/backend/jvm/BCodeIdiomatic.scala | 42 +- .../nsc/backend/jvm/BCodeSkelBuilder.scala | 35 +- .../tools/nsc/backend/jvm/BCodeTypes.scala | 930 ------------------ .../scala/tools/nsc/backend/jvm/BTypes.scala | 626 ++++++++---- .../nsc/backend/jvm/BTypesFromSymbols.scala | 384 ++++++++ .../tools/nsc/backend/jvm/CoreBTypes.scala | 257 +++++ .../tools/nsc/backend/jvm/GenBCode.scala | 14 +- .../tools/nsc/backend/jvm/BTypesTest.scala | 55 +- 10 files changed, 1298 insertions(+), 1537 deletions(-) delete mode 100644 src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala create mode 100644 src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala create mode 100644 src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index 2d1030121e68..542ff48c3366 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -92,7 +92,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { val thrownKind = tpeTK(expr) // `throw null` is valid although scala.Null (as defined in src/libray-aux) isn't a subtype of Throwable. // Similarly for scala.Nothing (again, as defined in src/libray-aux). - assert(thrownKind.isNullType || thrownKind.isNothingType || exemplars.get(thrownKind).isSubtypeOf(ThrowableReference)) + assert(thrownKind.isNullType || thrownKind.isNothingType || thrownKind.asClassBType.isSubtypeOf(ThrowableReference)) genLoad(expr, thrownKind) lineNumber(expr) emit(asm.Opcodes.ATHROW) // ICode enters here into enterIgnoreMode, we'll rely instead on DCE at ClassNode level. @@ -123,7 +123,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { // binary operation case rarg :: Nil => - resKind = maxType(tpeTK(larg), tpeTK(rarg)) + resKind = tpeTK(larg).maxType(tpeTK(rarg)) if (scalaPrimitives.isShiftOp(code) || scalaPrimitives.isBitwiseOp(code)) { assert(resKind.isIntegralType || (resKind == BOOL), s"$resKind incompatible with arithmetic modulo operation.") @@ -321,7 +321,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { mnode.visitVarInsn(asm.Opcodes.ALOAD, 0) generatedType = if (tree.symbol == ArrayClass) ObjectReference - else ClassBType(thisName) // inner class (if any) for claszSymbol already tracked. + else classBTypeFromSymbol(claszSymbol) } case Select(Ident(nme.EMPTY_PACKAGE_NAME), module) => @@ -459,9 +459,10 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { case ClazzTag => val toPush: BType = { - val kind = toTypeKind(const.typeValue) - if (kind.isPrimitive) classLiteral(kind) - else kind + toTypeKind(const.typeValue) match { + case kind: PrimitiveBType => boxedClassOfPrimitive(kind) + case kind => kind + } } mnode.visitLdcInsn(toPush.toASMType) @@ -558,7 +559,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { abort(s"Erasure should have added an unboxing operation to prevent this cast. Tree: $app") } else if (r.isPrimitive) { - bc isInstance classLiteral(r) + bc isInstance boxedClassOfPrimitive(r.asPrimitiveBType) } else { assert(r.isRef, r) // ensure that it's not a method @@ -619,7 +620,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { } case rt: ClassBType => - assert(exemplar(ctor.owner).c == rt, s"Symbol ${ctor.owner.fullName} is different from $rt") + assert(classBTypeFromSymbol(ctor.owner) == rt, s"Symbol ${ctor.owner.fullName} is different from $rt") mnode.visitTypeInsn(asm.Opcodes.NEW, rt.internalName) bc dup generatedType genLoadArguments(args, paramTKs(app)) @@ -632,16 +633,16 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { case Apply(fun @ _, List(expr)) if currentRun.runDefinitions.isBox(fun.symbol) => val nativeKind = tpeTK(expr) genLoad(expr, nativeKind) - val MethodNameAndType(mname, mdesc) = asmBoxTo(nativeKind) - bc.invokestatic(BoxesRunTime.internalName, mname, mdesc) + val MethodNameAndType(mname, methodType) = asmBoxTo(nativeKind) + bc.invokestatic(BoxesRunTime.internalName, mname, methodType.descriptor) generatedType = boxResultType(fun.symbol) // was toTypeKind(fun.symbol.tpe.resultType) case Apply(fun @ _, List(expr)) if currentRun.runDefinitions.isUnbox(fun.symbol) => genLoad(expr) val boxType = unboxResultType(fun.symbol) // was toTypeKind(fun.symbol.owner.linkedClassOfClass.tpe) generatedType = boxType - val MethodNameAndType(mname, mdesc) = asmUnboxTo(boxType) - bc.invokestatic(BoxesRunTime.internalName, mname, mdesc) + val MethodNameAndType(mname, methodType) = asmUnboxTo(boxType) + bc.invokestatic(BoxesRunTime.internalName, mname, methodType.descriptor) case app @ Apply(fun, args) => val sym = fun.symbol @@ -807,7 +808,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { } def adapt(from: BType, to: BType) { - if (!conforms(from, to)) { + if (!from.conformsTo(to)) { to match { case UNIT => bc drop from case _ => bc.emitT2T(from, to) @@ -948,7 +949,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { def genCallMethod(method: Symbol, style: InvokeStyle, hostClass0: Symbol = null, pos: Position = NoPosition) { val siteSymbol = claszSymbol - val hostSymbol = if (hostClass0 == null) method.owner else hostClass0; + val hostSymbol = if (hostClass0 == null) method.owner else hostClass0; val methodOwner = method.owner // info calls so that types are up to date; erasure may add lateINTERFACE to traits hostSymbol.info ; methodOwner.info @@ -966,8 +967,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { || methodOwner == definitions.ObjectClass ) val receiver = if (useMethodOwner) methodOwner else hostSymbol - val bmOwner = asmClassType(receiver) - val jowner = bmOwner.internalName + val jowner = internalName(receiver) val jname = method.javaSimpleName.toString val bmType = asmMethodType(method) val mdescr = bmType.descriptor @@ -1100,7 +1100,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { genCZJUMP(success, failure, op, ObjectReference) } else { - val tk = maxType(tpeTK(l), tpeTK(r)) + val tk = tpeTK(l).maxType(tpeTK(r)) genLoad(l, tk) genLoad(r, tk) genCJUMP(success, failure, op, tk) @@ -1206,7 +1206,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { genCZJUMP(success, failure, icodes.NE, BOOL) } else { // l == r -> if (l eq null) r eq null else l.equals(r) - val eqEqTempLocal = locals.makeLocal(AnyRefReference, nme.EQEQ_LOCAL_VAR.toString) + val eqEqTempLocal = locals.makeLocal(ObjectReference, nme.EQEQ_LOCAL_VAR.toString) val lNull = new asm.Label val lNonNull = new asm.Label diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala index de1587c7c3f8..e61be7411bee 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala @@ -8,8 +8,7 @@ package tools.nsc package backend.jvm import scala.tools.asm -import scala.annotation.switch -import scala.collection.{ immutable, mutable } +import scala.collection.mutable import scala.tools.nsc.io.AbstractFile /* @@ -19,7 +18,7 @@ import scala.tools.nsc.io.AbstractFile * @version 1.0 * */ -abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { +abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters { import global._ import bTypes._ @@ -53,24 +52,6 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { // https://issues.scala-lang.org/browse/SI-3872 // ----------------------------------------------------------------------------------------- - /* - * can-multi-thread - */ - def firstCommonSuffix(as: List[Tracked], bs: List[Tracked]): ClassBType = { - var chainA = as - var chainB = bs - var fcs: Tracked = null - do { - if (chainB contains chainA.head) fcs = chainA.head - else if (chainA contains chainB.head) fcs = chainB.head - else { - chainA = chainA.tail - chainB = chainB.tail - } - } while (fcs == null) - fcs.c - } - /* An `asm.ClassWriter` that uses `jvmWiseLUB()` * The internal name of the least common ancestor of the types given by inameA and inameB. * It's what ASM needs to know in order to compute stack map frames, http://asm.ow2.org/doc/developer-guide.html#controlflow @@ -78,57 +59,17 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { final class CClassWriter(flags: Int) extends asm.ClassWriter(flags) { /** - * This method is thread re-entrant because chrs never grows during its operation (that's - * because all TypeNames being looked up have already been entered). - * To stress this point, rather than using `newTypeName()` we use `lookupTypeName()` - * - * can-multi-thread + * This method is thread-safe: it depends only on the BTypes component, which does not depend + * on global. TODO @lry move to a different place where no global is in scope, on bTypes. */ override def getCommonSuperClass(inameA: String, inameB: String): String = { - val a = ClassBType(lookupTypeName(inameA.toCharArray)) - val b = ClassBType(lookupTypeName(inameB.toCharArray)) - val lca = jvmWiseLUB(a, b) - val lcaName = lca.internalName // don't call javaName because that side-effects innerClassBuffer. - assert(lcaName != "scala/Any") - - lcaName // ASM caches the answer during the lifetime of a ClassWriter. We outlive that. Not sure whether caching on our side would improve things. - } - - } - - /** - * Finding the least upper bound in agreement with the bytecode verifier (given two internal names - * handed out by ASM) - * Background: - * http://gallium.inria.fr/~xleroy/publi/bytecode-verification-JAR.pdf - * http://comments.gmane.org/gmane.comp.java.vm.languages/2293 - * https://issues.scala-lang.org/browse/SI-3872 - * - * can-multi-thread - */ - def jvmWiseLUB(a: ClassBType, b: ClassBType): ClassBType = { - - assert(a.isNonSpecial, s"jvmWiseLUB() received a non-plain-class $a") - assert(b.isNonSpecial, s"jvmWiseLUB() received a non-plain-class $b") - - val ta = exemplars.get(a) - val tb = exemplars.get(b) - - val res = (ta.isInterface, tb.isInterface) match { - case (true, true) => - // exercised by test/files/run/t4761.scala - if (tb.isSubtypeOf(ta.c)) ta.c - else if (ta.isSubtypeOf(tb.c)) tb.c - else ObjectReference - case (true, false) => - if (tb.isSubtypeOf(a)) a else ObjectReference - case (false, true) => - if (ta.isSubtypeOf(b)) b else ObjectReference - case _ => - firstCommonSuffix(ta :: ta.superClasses, tb :: tb.superClasses) + val a = classBTypeFromInternalName(inameA) + val b = classBTypeFromInternalName(inameB) + val lub = a.jvmWiseLUB(b) + val lubName = lub.internalName + assert(lubName != "scala/Any") + lubName // ASM caches the answer during the lifetime of a ClassWriter. We outlive that. Not sure whether caching on our side would improve things. } - assert(res.isNonSpecial, "jvmWiseLUB() returned a non-plain-class.") - res } /* @@ -230,7 +171,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { def fieldSymbols(cls: Symbol): List[Symbol] = { for (f <- cls.info.decls.toList ; if !f.isMethod && f.isTerm && !f.isModule - ) yield f; + ) yield f } /* @@ -261,38 +202,16 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { * * can-multi-thread */ - final def addInnerClassesASM(jclass: asm.ClassVisitor, refedInnerClasses: Iterable[BType]) { - // used to detect duplicates. - val seen = mutable.Map.empty[String, String] - // result without duplicates, not yet sorted. - val result = mutable.Set.empty[InnerClassEntry] - - for(s: BType <- refedInnerClasses; - e: InnerClassEntry <- exemplars.get(s).innersChain) { - - assert(e.name != null, "saveInnerClassesFor() is broken.") // documentation - val doAdd = seen.get(e.name) match { - // TODO is it ok for prevOName to be null? (Someone should really document the invariants of the InnerClasses bytecode attribute) - case Some(prevOName) => - // this occurs e.g. when innerClassBuffer contains both class Thread$State, object Thread$State, - // i.e. for them it must be the case that oname == java/lang/Thread - assert(prevOName == e.outerName, "duplicate") - false - case None => true - } - - if (doAdd) { - seen += (e.name -> e.outerName) - result += e - } - + final def addInnerClassesASM(jclass: asm.ClassVisitor, refedInnerClasses: List[ClassBType]) { + val allNestedClasses = refedInnerClasses.flatMap(_.enclosingNestedClassesChain).distinct + + // sorting ensures nested classes are listed after their enclosing class thus satisfying the Eclipse Java compiler + for (nestedClass <- allNestedClasses.sortBy(_.internalName.toString)) { + // Extract the innerClassEntry - we know it exists, enclosingNestedClassesChain only returns nested classes. + val Some(e) = nestedClass.innerClassAttributeEntry + jclass.visitInnerClass(e.name, e.outerName, e.innerName, e.flags) } - // sorting ensures inner classes are listed after their enclosing class thus satisfying the Eclipse Java compiler - for(e <- result.toList sortBy (_.name.toString)) { - jclass.visitInnerClass(e.name, e.outerName, e.innerName, e.access) - } - - } // end of method addInnerClassesASM() + } /* * Custom attribute (JVMS 4.7.1) "ScalaSig" used as marker only @@ -323,8 +242,8 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { * can-multi-thread */ def createJAttribute(name: String, b: Array[Byte], offset: Int, len: Int): asm.Attribute = { - val dest = new Array[Byte](len); - System.arraycopy(b, offset, dest, 0, len); + val dest = new Array[Byte](len) + System.arraycopy(b, offset, dest, 0, len) new asm.CustomAttr(name, dest) } @@ -385,9 +304,9 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { def debugLevel = settings.debuginfo.indexOfChoice - val emitSource = debugLevel >= 1 - val emitLines = debugLevel >= 2 - val emitVars = debugLevel >= 3 + final val emitSource = debugLevel >= 1 + final val emitLines = debugLevel >= 2 + final val emitVars = debugLevel >= 3 /* * Contains class-symbols that: @@ -396,155 +315,144 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { * * In other words, the lifetime of `innerClassBufferASM` is associated to "the class being generated". */ - val innerClassBufferASM = mutable.Set.empty[BType] + final val innerClassBufferASM = mutable.Set.empty[ClassBType] - /* - * Tracks (if needed) the inner class given by `sym`. - * - * must-single-thread + /** + * The class internal name for a given class symbol. If the symbol describes a nested class, the + * ClassBType is added to the innerClassBufferASM. */ - final def internalName(sym: Symbol): String = asmClassType(sym).internalName + final def internalName(sym: Symbol): String = { + // For each java class, the scala compiler creates a class and a module (thus a module class). + // If the `sym` is a java module class, we use the java class instead. This ensures that we + // register the class (instead of the module class) in innerClassBufferASM. + // The two symbols have the same name, so the resulting internalName is the same. + val classSym = if (sym.isJavaDefined && sym.isModuleClass) sym.linkedClassOfClass else sym + getClassBTypeAndRegisterInnerClass(classSym).internalName + } - /* - * Tracks (if needed) the inner class given by `sym`. + @inline private def assertClassNotArray(sym: Symbol): Unit = { + assert(sym.isClass, sym) + assert(sym != definitions.ArrayClass || isCompilingArray, sym) + } + + @inline private def assertClassNotArrayNotPrimitive(sym: Symbol): Unit = { + assertClassNotArray(sym) + assert(!primitiveTypeMap.contains(sym) || isCompilingPrimitive, sym) + } + + /** + * The ClassBType for a class symbol. If the class is nested, the ClassBType is added to the + * innerClassBufferASM. * - * must-single-thread + * The class symbol scala.Nothing is mapped to the class scala.runtime.Nothing$. Similarly, + * scala.Null is mapped to scala.runtime.Null$. This is because there exist no class files + * for the Nothing / Null. If used for example as a parameter type, we use the runtime classes + * in the classfile method signature. + * + * Note that the referenced class symbol may be an implementation class. For example when + * compiling a mixed-in method that forwards to the static method in the implementation class, + * the class descriptor of the receiver (the implementation class) is obtained by creating the + * ClassBType. */ - final def asmClassType(sym: Symbol): ClassBType = { - assert( - hasInternalName(sym), - { - val msg0 = if (sym.isAbstractType) "An AbstractTypeSymbol (SI-7122) " else "A symbol "; - msg0 + s"has reached the bytecode emitter, for which no JVM-level internal name can be found: ${sym.fullName}" - } - ) - val phantOpt = phantomTypeMap.get(sym) - if (phantOpt.isDefined) { - return phantOpt.get - } - val tracked = exemplar(sym) - val tk = tracked.c - if (tracked.isInnerClass) { - innerClassBufferASM += tk - } + final def getClassBTypeAndRegisterInnerClass(sym: Symbol): ClassBType = { + assertClassNotArrayNotPrimitive(sym) - tk + if (sym == definitions.NothingClass) RT_NOTHING + else if (sym == definitions.NullClass) RT_NULL + else { + val r = classBTypeFromSymbol(sym) + if (r.isNestedClass) innerClassBufferASM += r + r + } } - /* - * Returns the BType for the given type. - * Tracks (if needed) the inner class given by `t`. + /** + * This method returns the BType for a type reference, for example a parameter type. * - * must-single-thread + * If the result is a ClassBType for a nested class, it is added to the innerClassBufferASM. + * + * If `t` references a class, toTypeKind ensures that the class is not an implementation class. + * See also comment on getClassBTypeAndRegisterInnerClass, which is invoked for implementation + * classes. */ final def toTypeKind(t: Type): BType = { + import definitions.ArrayClass - /* Interfaces have to be handled delicately to avoid introducing spurious errors, - * but if we treat them all as AnyRef we lose too much information. + /** + * Primitive types are represented as TypeRefs to the class symbol of, for example, scala.Int. + * The `primitiveTypeMap` maps those class symbols to the corresponding PrimitiveBType. */ - def newReference(sym0: Symbol): BType = { - assert(!primitiveTypeMap.contains(sym0), "Use primitiveTypeMap instead.") - assert(sym0 != definitions.ArrayClass, "Use arrayOf() instead.") - - if (sym0 == definitions.NullClass) return RT_NULL; - if (sym0 == definitions.NothingClass) return RT_NOTHING; - - val sym = ( - if (!sym0.isPackageClass) sym0 - else sym0.info.member(nme.PACKAGE) match { - case NoSymbol => abort(s"SI-5604: Cannot use package as value: ${sym0.fullName}") - case s => abort(s"SI-5604: found package class where package object expected: $s") - } - ) - - // Can't call .toInterface (at this phase) or we trip an assertion. - // See PackratParser#grow for a method which fails with an apparent mismatch - // between "object PackratParsers$class" and "trait PackratParsers" - // TODO @lry do we have a test for that? - if (sym.isImplClass) { - // pos/spec-List.scala is the sole failure if we don't check for NoSymbol - val traitSym = sym.owner.info.decl(tpnme.interfaceName(sym.name)) - if (traitSym != NoSymbol) { - // this tracks the inner class in innerClassBufferASM, if needed. - return asmClassType(traitSym) - } - } - - // TODO @lry: code duplication between here and method asmClassType. - - assert(hasInternalName(sym), s"Invoked for a symbol lacking JVM internal name: ${sym.fullName}") - assert(!phantomTypeMap.contains(sym), "phantom types not supposed to reach here.") - - val tracked = exemplar(sym) - val tk = tracked.c - if (tracked.isInnerClass) { - innerClassBufferASM += tk - } - - tk + def primitiveOrClassToBType(sym: Symbol): BType = { + assertClassNotArray(sym) + primitiveTypeMap.getOrElse(sym, classOrImplClassToBType(sym)) } - def primitiveOrRefType(sym: Symbol): BType = { - assert(sym != definitions.ArrayClass, "Use primitiveOrArrayOrRefType() instead.") - - primitiveTypeMap.getOrElse(sym, newReference(sym)) + /** + * The ClassBType for a class or interface reference. Asserts that `sym` is not an + * implementation class. + */ + def classOrImplClassToBType(sym: Symbol): ClassBType = { + assertClassNotArrayNotPrimitive(sym) + assert(!sym.isImplClass, s"typeKind of implementation class $sym") + getClassBTypeAndRegisterInnerClass(sym) } - def primitiveOrRefType2(sym: Symbol): BType = { - primitiveTypeMap.get(sym) match { - case Some(pt) => pt - case None => - sym match { - case definitions.NullClass => RT_NULL - case definitions.NothingClass => RT_NOTHING - case _ if sym.isClass => newReference(sym) - case _ => - assert(sym.isType, sym) // it must be compiling Array[a] - ObjectReference - } - } + /** + * When compiling Array.scala, the type parameter T is not erased and shows up in method + * signatures, e.g. `def apply(i: Int): T`. A TyperRef to T is replaced by ObjectReference. + */ + def nonClassTypeRefToBType(sym: Symbol): ClassBType = { + assert(sym.isType && isCompilingArray, sym) + ObjectReference } - import definitions.ArrayClass - - // Call to .normalize fixes #3003 (follow type aliases). Otherwise, primitiveOrArrayOrRefType() would return ObjectReference. - t.normalize match { - - case ThisType(sym) => - if (sym == ArrayClass) ObjectReference - else phantomTypeMap.getOrElse(sym, exemplar(sym).c) - - case SingleType(_, sym) => primitiveOrRefType(sym) - - case _: ConstantType => toTypeKind(t.underlying) - - case TypeRef(_, sym, args) => - if (sym == ArrayClass) ArrayBType(toTypeKind(args.head)) - else primitiveOrRefType2(sym) - - case ClassInfoType(_, _, sym) => - assert(sym != ArrayClass, "ClassInfoType to ArrayClass!") - primitiveOrRefType(sym) - - // TODO @lry check below comments / todo's - // !!! Iulian says types which make no sense after erasure should not reach here, which includes the ExistentialType, AnnotatedType, RefinedType. - case ExistentialType(_, t) => toTypeKind(t) // TODO shouldn't get here but the following does: akka-actor/src/main/scala/akka/util/WildcardTree.scala - case AnnotatedType(_, w) => toTypeKind(w) // TODO test/files/jvm/annotations.scala causes an AnnotatedType to reach here. - case RefinedType(parents, _) => parents.map(toTypeKind(_).asClassBType) reduceLeft jvmWiseLUB - - // For sure WildcardTypes shouldn't reach here either, but when debugging such situations this may come in handy. - // case WildcardType => REFERENCE(ObjectClass) - case norm => abort( - s"Unknown type: $t, $norm [${t.getClass}, ${norm.getClass}] TypeRef? ${t.isInstanceOf[TypeRef]}" - ) + t.dealiasWiden match { + case TypeRef(_, ArrayClass, List(arg)) => ArrayBType(toTypeKind(arg)) // Array type such as Array[Int] (kept by erasure) + case TypeRef(_, sym, _) if !sym.isClass => nonClassTypeRefToBType(sym) // See comment on nonClassTypeRefToBType + case TypeRef(_, sym, _) => primitiveOrClassToBType(sym) // Common reference to a type such as scala.Int or java.lang.String + case ClassInfoType(_, _, sym) => primitiveOrClassToBType(sym) // We get here, for example, for genLoadModule, which invokes toTypeKind(moduleClassSymbol.info) + + /* AnnotatedType should (probably) be eliminated by erasure. However we know it happens for + * meta-annotated annotations (@(ann @getter) val x = 0), so we don't emit a warning. + * The type in the AnnotationInfo is an AnnotatedTpe. Tested in jvm/annotations.scala. + */ + case a @ AnnotatedType(_, t) => + debuglog(s"typeKind of annotated type $a") + toTypeKind(t) + + /* ExistentialType should (probably) be eliminated by erasure. We know they get here for + * classOf constants: + * class C[T] + * class T { final val k = classOf[C[_]] } + */ + case e @ ExistentialType(_, t) => + debuglog(s"typeKind of existential type $e") + toTypeKind(t) + + /* The cases below should probably never occur. They are kept for now to avoid introducing + * new compiler crashes, but we added a warning. The compiler / library bootstrap and the + * test suite don't produce any warning. + */ + + case tp => + currentUnit.warning(tp.typeSymbol.pos, + s"an unexpected type representation reached the compiler backend while compiling $currentUnit: $tp. " + + "If possible, please file a bug on issues.scala-lang.org.") + + tp match { + case ThisType(ArrayClass) => ObjectReference // was introduced in 9b17332f11 to fix SI-999, but this code is not reached in its test, or any other test + case ThisType(sym) => getClassBTypeAndRegisterInnerClass(sym) + case SingleType(_, sym) => primitiveOrClassToBType(sym) + case ConstantType(_) => toTypeKind(t.underlying) + case RefinedType(parents, _) => parents.map(toTypeKind(_).asClassBType).reduceLeft((a, b) => a.jvmWiseLUB(b)) + } } - - } // end of method toTypeKind() + } /* * must-single-thread */ - def asmMethodType(msym: Symbol): MethodBType = { + final def asmMethodType(msym: Symbol): MethodBType = { assert(msym.isMethod, s"not a method-symbol: $msym") val resT: BType = if (msym.isClassConstructor || msym.isConstructor) UNIT @@ -552,45 +460,17 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { MethodBType(msym.tpe.paramTypes map toTypeKind, resT) } - /* - * Returns all direct member inner classes of `csym`, - * thus making sure they get entries in the InnerClasses JVM attribute - * even if otherwise not mentioned in the class being built. - * - * must-single-thread - */ - final def trackMemberClasses(csym: Symbol, lateClosuresBTs: List[BType]): List[BType] = { - val lateInnerClasses = exitingErasure { - for (sym <- List(csym, csym.linkedClassOfClass); memberc <- sym.info.decls.map(innerClassSymbolFor) if memberc.isClass) - yield memberc - } - // as a precaution, do the following outside the above `exitingErasure` otherwise funny internal names might be computed. - val result = for(memberc <- lateInnerClasses) yield { - val tracked = exemplar(memberc) - val memberCTK = tracked.c - assert(tracked.isInnerClass, s"saveInnerClassesFor() says this was no inner-class after all: ${memberc.fullName}") - - memberCTK - } - - exemplar(csym).directMemberClasses = result - - result - } - - /* - * Tracks (if needed) the inner class given by `t`. - * - * must-single-thread + /** + * The jvm descriptor of a type. If `t` references a nested class, its ClassBType is added to + * the innerClassBufferASM. */ final def descriptor(t: Type): String = { toTypeKind(t).descriptor } - /* - * Tracks (if needed) the inner class given by `sym`. - * - * must-single-thread + /** + * The jvm descriptor for a symbol. If `sym` represents a nested class, its ClassBType is added + * to the innerClassBufferASM. */ - final def descriptor(sym: Symbol): String = { asmClassType(sym).descriptor } + final def descriptor(sym: Symbol): String = { getClassBTypeAndRegisterInnerClass(sym).descriptor } } // end of trait BCInnerClassGen @@ -795,7 +675,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { */ // TODO: evaluate the other flags we might be dropping on the floor here. // TODO: ACC_SYNTHETIC ? - val flags = PublicStatic | ( + val flags = GenBCode.PublicStatic | ( if (m.isVarargsMethod) asm.Opcodes.ACC_VARARGS else 0 ) @@ -901,7 +781,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { def addSerialVUID(id: Long, jclass: asm.ClassVisitor) { // add static serialVersionUID field if `clasz` annotated with `@SerialVersionUID(uid: Long)` jclass.visitField( - PublicStaticFinal, + GenBCode.PublicStaticFinal, "serialVersionUID", "J", null, // no java-generic-signature @@ -985,11 +865,12 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { * * must-single-thread */ - def genMirrorClass(modsym: Symbol, cunit: CompilationUnit): asm.tree.ClassNode = { - assert(modsym.companionClass == NoSymbol, modsym) + def genMirrorClass(moduleClass: Symbol, cunit: CompilationUnit): asm.tree.ClassNode = { + assert(moduleClass.isModuleClass) + assert(moduleClass.companionClass == NoSymbol, moduleClass) innerClassBufferASM.clear() this.cunit = cunit - val moduleName = internalName(modsym) // + "$" + val moduleName = internalName(moduleClass) // + "$" val mirrorName = moduleName.substring(0, moduleName.length() - 1) val flags = (asm.Opcodes.ACC_SUPER | asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_FINAL) @@ -999,7 +880,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { flags, mirrorName, null /* no java-generic-signature */, - JAVA_LANG_OBJECT.internalName, + ObjectReference.internalName, EMPTY_STRING_ARRAY ) @@ -1008,18 +889,18 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { null /* SourceDebugExtension */) } - val ssa = getAnnotPickle(mirrorName, modsym.companionSymbol) + val ssa = getAnnotPickle(mirrorName, moduleClass.companionSymbol) mirrorClass.visitAttribute(if (ssa.isDefined) pickleMarkerLocal else pickleMarkerForeign) - emitAnnotations(mirrorClass, modsym.annotations ++ ssa) + emitAnnotations(mirrorClass, moduleClass.annotations ++ ssa) - addForwarders(isRemote(modsym), mirrorClass, mirrorName, modsym) + addForwarders(isRemote(moduleClass), mirrorClass, mirrorName, moduleClass) - innerClassBufferASM ++= trackMemberClasses(modsym, Nil /* TODO what about Late-Closure-Classes */ ) + innerClassBufferASM ++= classBTypeFromSymbol(moduleClass).info.memberClasses addInnerClassesASM(mirrorClass, innerClassBufferASM.toList) mirrorClass.visitEnd() - ("" + modsym.name) // this side-effect is necessary, really. + ("" + moduleClass.name) // this side-effect is necessary, really. mirrorClass } @@ -1042,7 +923,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { innerClassBufferASM.clear() - val flags = mkFlags( + val flags = GenBCode.mkFlags( javaFlags(cls), if (isDeprecated(cls)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo access flag ) @@ -1091,9 +972,9 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { EMPTY_STRING_ARRAY // no throwable exceptions ) - val stringArrayJType: BType = ArrayBType(JAVA_LANG_STRING) + val stringArrayJType: BType = ArrayBType(StringReference) val conJType: BType = MethodBType( - exemplar(definitions.ClassClass).c :: stringArrayJType :: stringArrayJType :: Nil, + classBTypeFromSymbol(definitions.ClassClass) :: stringArrayJType :: stringArrayJType :: Nil, UNIT ) @@ -1104,7 +985,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { constructor.visitLdcInsn(new java.lang.Integer(fi)) if (f == null) { constructor.visitInsn(asm.Opcodes.ACONST_NULL) } else { constructor.visitLdcInsn(f) } - constructor.visitInsn(JAVA_LANG_STRING.typedOpcode(asm.Opcodes.IASTORE)) + constructor.visitInsn(StringReference.typedOpcode(asm.Opcodes.IASTORE)) fi += 1 } } @@ -1113,16 +994,16 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { constructor.visitVarInsn(asm.Opcodes.ALOAD, 0) // push the class - constructor.visitLdcInsn(exemplar(cls).c.toASMType) + constructor.visitLdcInsn(classBTypeFromSymbol(cls).toASMType) // push the string array of field information constructor.visitLdcInsn(new java.lang.Integer(fieldList.length)) - constructor.visitTypeInsn(asm.Opcodes.ANEWARRAY, JAVA_LANG_STRING.internalName) + constructor.visitTypeInsn(asm.Opcodes.ANEWARRAY, StringReference.internalName) push(fieldList) // push the string array of method information constructor.visitLdcInsn(new java.lang.Integer(methodList.length)) - constructor.visitTypeInsn(asm.Opcodes.ANEWARRAY, JAVA_LANG_STRING.internalName) + constructor.visitTypeInsn(asm.Opcodes.ANEWARRAY, StringReference.internalName) push(methodList) // invoke the superclass constructor, which will do the @@ -1133,7 +1014,7 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { constructor.visitMaxs(0, 0) // just to follow protocol, dummy arguments constructor.visitEnd() - innerClassBufferASM ++= trackMemberClasses(cls, Nil /* TODO what about Late-Closure-Classes */ ) + innerClassBufferASM ++= classBTypeFromSymbol(cls).info.memberClasses addInnerClassesASM(beanInfoClass, innerClassBufferASM.toList) beanInfoClass.visitEnd() @@ -1165,11 +1046,11 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { */ def legacyAddCreatorCode(clinit: asm.MethodVisitor, cnode: asm.tree.ClassNode, thisName: String) { // this tracks the inner class in innerClassBufferASM, if needed. - val androidCreatorType = asmClassType(AndroidCreatorClass) + val androidCreatorType = getClassBTypeAndRegisterInnerClass(AndroidCreatorClass) val tdesc_creator = androidCreatorType.descriptor cnode.visitField( - PublicStaticFinal, + GenBCode.PublicStaticFinal, "CREATOR", tdesc_creator, null, // no java-generic-signature @@ -1206,5 +1087,4 @@ abstract class BCodeHelpers extends BCodeTypes with BytecodeWriters { } } // end of trait JAndroidBuilder - } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala index 2343d378db7b..290e899ba4d0 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala @@ -21,11 +21,7 @@ import scala.collection.mutable abstract class BCodeIdiomatic extends SubComponent { protected val bCodeICodeCommon: BCodeICodeCommon[global.type] = new BCodeICodeCommon(global) - val bTypes = new BTypes[global.type](global) { - def chrs = global.chrs - override type BTypeName = global.TypeName - override def createNewName(s: String) = global.newTypeName(s) - } + val bTypes = new BTypesFromSymbols[global.type](global) import global._ import bTypes._ @@ -40,9 +36,7 @@ abstract class BCodeIdiomatic extends SubComponent { val majorVersion: Int = (classfileVersion & 0xFF) val emitStackMapFrame = (majorVersion >= 50) - def mkFlags(args: Int*) = args.foldLeft(0)(_ | _) - - val extraProc: Int = mkFlags( + val extraProc: Int = GenBCode.mkFlags( asm.ClassWriter.COMPUTE_MAXS, if (emitStackMapFrame) asm.ClassWriter.COMPUTE_FRAMES else 0 ) @@ -52,15 +46,6 @@ abstract class BCodeIdiomatic extends SubComponent { val CLASS_CONSTRUCTOR_NAME = "" val INSTANCE_CONSTRUCTOR_NAME = "" - val ObjectReference = ClassBType("java/lang/Object") - val AnyRefReference = ObjectReference - val objArrayReference = ArrayBType(ObjectReference) - - val JAVA_LANG_OBJECT = ObjectReference - val JAVA_LANG_STRING = ClassBType("java/lang/String") - - var StringBuilderReference: BType = null - val EMPTY_STRING_ARRAY = Array.empty[String] val EMPTY_INT_ARRAY = Array.empty[Int] val EMPTY_LABEL_ARRAY = Array.empty[asm.Label] @@ -239,7 +224,7 @@ abstract class BCodeIdiomatic extends SubComponent { final def genStringConcat(el: BType) { val jtype = - if (el.isArray || el.isClass) JAVA_LANG_OBJECT + if (el.isArray || el.isClass) ObjectReference else el val bt = MethodBType(List(jtype), StringBuilderReference) @@ -266,7 +251,7 @@ abstract class BCodeIdiomatic extends SubComponent { assert( from.isNonVoidPrimitiveType && to.isNonVoidPrimitiveType, - s"Cannot emit primitive conversion from $from to $to" + s"Cannot emit primitive conversion from $from to $to - ${global.currentUnit}" ) def pickOne(opcs: Array[Int]) { // TODO index on to.sort @@ -537,7 +522,7 @@ abstract class BCodeIdiomatic extends SubComponent { final def emitTypeBased(opcs: Array[Int], tk: BType) { assert(tk != UNIT, tk) val opc = { - if (tk.isRef) { opcs(0) } + if (tk.isRef) { opcs(0) } else if (tk.isIntSizedType) { (tk: @unchecked) match { case BOOL | BYTE => opcs(1) @@ -648,7 +633,7 @@ abstract class BCodeIdiomatic extends SubComponent { */ final def coercionTo(code: Int): BType = { import scalaPrimitives._ - (code: @scala.annotation.switch) match { + (code: @switch) match { case B2B | C2B | S2B | I2B | L2B | F2B | D2B => BYTE case B2C | C2C | S2C | I2C | L2C | F2C | D2C => CHAR case B2S | C2S | S2S | I2S | L2S | F2S | D2S => SHORT @@ -659,21 +644,6 @@ abstract class BCodeIdiomatic extends SubComponent { } } - final val typeOfArrayOp: Map[Int, BType] = { - import scalaPrimitives._ - Map( - (List(ZARRAY_LENGTH, ZARRAY_GET, ZARRAY_SET) map (_ -> BOOL)) ++ - (List(BARRAY_LENGTH, BARRAY_GET, BARRAY_SET) map (_ -> BYTE)) ++ - (List(SARRAY_LENGTH, SARRAY_GET, SARRAY_SET) map (_ -> SHORT)) ++ - (List(CARRAY_LENGTH, CARRAY_GET, CARRAY_SET) map (_ -> CHAR)) ++ - (List(IARRAY_LENGTH, IARRAY_GET, IARRAY_SET) map (_ -> INT)) ++ - (List(LARRAY_LENGTH, LARRAY_GET, LARRAY_SET) map (_ -> LONG)) ++ - (List(FARRAY_LENGTH, FARRAY_GET, FARRAY_SET) map (_ -> FLOAT)) ++ - (List(DARRAY_LENGTH, DARRAY_GET, DARRAY_SET) map (_ -> DOUBLE)) ++ - (List(OARRAY_LENGTH, OARRAY_GET, OARRAY_SET) map (_ -> ObjectReference)) : _* - ) - } - /* * Collects (in `result`) all LabelDef nodes enclosed (directly or not) by each node it visits. * diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala index 0d67a07e0f6e..46399041451d 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala @@ -116,7 +116,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { addClassFields() - innerClassBufferASM ++= trackMemberClasses(claszSymbol, Nil) + innerClassBufferASM ++= classBTypeFromSymbol(claszSymbol).info.memberClasses gen(cd.impl) addInnerClassesASM(cnode, innerClassBufferASM.toList) @@ -134,23 +134,14 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { private def initJClass(jclass: asm.ClassVisitor) { val ps = claszSymbol.info.parents - val superClass: String = if (ps.isEmpty) JAVA_LANG_OBJECT.internalName else internalName(ps.head.typeSymbol); - val ifaces: Array[String] = { - val arrIfacesTr: Array[Tracked] = exemplar(claszSymbol).ifaces - val arrIfaces = new Array[String](arrIfacesTr.length) - var i = 0 - while (i < arrIfacesTr.length) { - val ifaceTr = arrIfacesTr(i) - val bt = ifaceTr.c - if (ifaceTr.isInnerClass) { innerClassBufferASM += bt } - arrIfaces(i) = bt.internalName - i += 1 - } - arrIfaces + val superClass: String = if (ps.isEmpty) ObjectReference.internalName else internalName(ps.head.typeSymbol) + val interfaceNames = classBTypeFromSymbol(claszSymbol).info.interfaces map { + case classBType => + if (classBType.isNestedClass) { innerClassBufferASM += classBType } + classBType.internalName } - // `internalName()` tracks inner classes. - val flags = mkFlags( + val flags = GenBCode.mkFlags( javaFlags(claszSymbol), if (isDeprecated(claszSymbol)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo access flag ) @@ -158,7 +149,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { val thisSignature = getGenericSignature(claszSymbol, claszSymbol.owner) cnode.visit(classfileVersion, flags, thisName, thisSignature, - superClass, ifaces) + superClass, interfaceNames.toArray) if (emitSource) { cnode.visitSource(cunit.source.toString, null /* SourceDebugExtension */) @@ -207,7 +198,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { */ private def addModuleInstanceField() { val fv = - cnode.visitField(PublicStaticFinal, // TODO confirm whether we really don't want ACC_SYNTHETIC nor ACC_DEPRECATED + cnode.visitField(GenBCode.PublicStaticFinal, // TODO confirm whether we really don't want ACC_SYNTHETIC nor ACC_DEPRECATED strMODULE_INSTANCE_FIELD, "L" + thisName + ";", null, // no java-generic-signature @@ -223,7 +214,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { private def fabricateStaticInit() { val clinit: asm.MethodVisitor = cnode.visitMethod( - PublicStatic, // TODO confirm whether we really don't want ACC_SYNTHETIC nor ACC_DEPRECATED + GenBCode.PublicStatic, // TODO confirm whether we really don't want ACC_SYNTHETIC nor ACC_DEPRECATED CLASS_CONSTRUCTOR_NAME, "()V", null, // no java-generic-signature @@ -254,7 +245,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { */ for (f <- fieldSymbols(claszSymbol)) { val javagensig = getGenericSignature(f, claszSymbol) - val flags = mkFlags( + val flags = GenBCode.mkFlags( javaFieldFlags(f), if (isDeprecated(f)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo access flag ) @@ -576,7 +567,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { val isNative = methSymbol.hasAnnotation(definitions.NativeAttr) val isAbstractMethod = (methSymbol.isDeferred || methSymbol.owner.isInterface) - val flags = mkFlags( + val flags = GenBCode.mkFlags( javaFlags(methSymbol), if (claszSymbol.isInterface) asm.Opcodes.ACC_ABSTRACT else 0, if (methSymbol.isStrictFP) asm.Opcodes.ACC_STRICT else 0, @@ -695,7 +686,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { // android creator code if (isCZParcelable) { // add a static field ("CREATOR") to this class to cache android.os.Parcelable$Creator - val andrFieldDescr = asmClassType(AndroidCreatorClass).descriptor + val andrFieldDescr = getClassBTypeAndRegisterInnerClass(AndroidCreatorClass).descriptor cnode.visitField( asm.Opcodes.ACC_STATIC | asm.Opcodes.ACC_FINAL, "CREATOR", diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala deleted file mode 100644 index b373f8d74d72..000000000000 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala +++ /dev/null @@ -1,930 +0,0 @@ -/* NSC -- new Scala compiler - * Copyright 2005-2012 LAMP/EPFL - * @author Martin Odersky - */ - -package scala -package tools.nsc -package backend.jvm - -import scala.tools.asm -import scala.collection.{ immutable, mutable } - -/* - * Utilities to mediate between types as represented in Scala ASTs and ASM trees. - * - * @author Miguel Garcia, http://lamp.epfl.ch/~magarcia/ScalaCompilerCornerReloaded - * @version 1.0 - * - */ -abstract class BCodeTypes extends BCodeIdiomatic { - import global._ - import bTypes._ - - // Used only for assertions. When compiling the Scala library, some assertions don't hold - // (e.g., scala.Boolean has null superClass although it's not an interface) - private val isCompilingStdLib = !(settings.sourcepath.isDefault) - - // special names - var StringReference : ClassBType = null - var ThrowableReference : ClassBType = null - var jlCloneableReference : ClassBType = null // java/lang/Cloneable - var jlNPEReference : ClassBType = null // java/lang/NullPointerException - var jioSerializableReference : ClassBType = null // java/io/Serializable - var scalaSerializableReference : ClassBType = null // scala/Serializable - var classCastExceptionReference : ClassBType = null // java/lang/ClassCastException - - /* A map from scala primitive type-symbols to BTypes */ - var primitiveTypeMap: Map[Symbol, BType] = null - /* A map from scala type-symbols for Nothing and Null to (runtime version) BTypes */ - var phantomTypeMap: Map[Symbol, ClassBType] = null - /* Maps the method symbol for a box method to the boxed type of the result. - * For example, the method symbol for `Byte.box()`) is mapped to the BType `Ljava/lang/Integer;`. */ - var boxResultType: Map[Symbol, BType] = null - /* Maps the method symbol for an unbox method to the primitive type of the result. - * For example, the method symbol for `Byte.unbox()`) is mapped to the BType BYTE. */ - var unboxResultType: Map[Symbol, BType] = null - - var hashMethodSym: Symbol = null // scala.runtime.ScalaRunTime.hash - - var AndroidParcelableInterface: Symbol = null - var AndroidCreatorClass : Symbol = null // this is an inner class, use asmType() to get hold of its BType while tracking in innerClassBufferASM - - var BeanInfoAttr: Symbol = null - - /* The Object => String overload. */ - var String_valueOf: Symbol = null - - var ArrayInterfaces: Set[Tracked] = null - - // scala.FunctionX and scala.runtim.AbstractFunctionX - val FunctionReference = new Array[Tracked](definitions.MaxFunctionArity + 1) - val AbstractFunctionReference = new Array[Tracked](definitions.MaxFunctionArity + 1) - val abstractFunctionArityMap = mutable.Map.empty[BType, Int] - - var PartialFunctionReference: ClassBType = null // scala.PartialFunction - var AbstractPartialFunctionReference: ClassBType = null // scala.runtime.AbstractPartialFunction - - var BoxesRunTime: ClassBType = null - - /* - * must-single-thread - */ - def initBCodeTypes() { - import definitions._ - - primitiveTypeMap = - Map( - UnitClass -> UNIT, - BooleanClass -> BOOL, - CharClass -> CHAR, - ByteClass -> BYTE, - ShortClass -> SHORT, - IntClass -> INT, - LongClass -> LONG, - FloatClass -> FLOAT, - DoubleClass -> DOUBLE - ) - - phantomTypeMap = - Map( - NothingClass -> RT_NOTHING, - NullClass -> RT_NULL, - NothingClass -> RT_NOTHING, // we map on purpose to RT_NOTHING, getting rid of the distinction compile-time vs. runtime for NullClass. - NullClass -> RT_NULL // ditto. - ) - - boxResultType = - for((csym, msym) <- currentRun.runDefinitions.boxMethod) - yield (msym -> classLiteral(primitiveTypeMap(csym))) - - unboxResultType = - for((csym, msym) <- currentRun.runDefinitions.unboxMethod) - yield (msym -> primitiveTypeMap(csym)) - - // boxed classes are looked up in the `exemplars` map by jvmWiseLUB(). - // Other than that, they aren't needed there (e.g., `isSubtypeOf()` special-cases boxed classes, similarly for others). - val boxedClasses = List(BoxedBooleanClass, BoxedCharacterClass, BoxedByteClass, BoxedShortClass, BoxedIntClass, BoxedLongClass, BoxedFloatClass, BoxedDoubleClass) - for(csym <- boxedClasses) { - val key = ClassBType(csym.javaBinaryName.toTypeName) - val tr = buildExemplar(key, csym) - symExemplars.put(csym, tr) - exemplars.put(tr.c, tr) - } - - // reversePrimitiveMap = (primitiveTypeMap map { case (s, pt) => (s.tpe, pt) } map (_.swap)).toMap - - hashMethodSym = getMember(ScalaRunTimeModule, nme.hash_) - - // TODO avoiding going through through missingHook for every line in the REPL: https://github.com/scala/scala/commit/8d962ed4ddd310cc784121c426a2e3f56a112540 - AndroidParcelableInterface = rootMirror.getClassIfDefined("android.os.Parcelable") - AndroidCreatorClass = rootMirror.getClassIfDefined("android.os.Parcelable$Creator") - - // the following couldn't be an eager vals in Phase constructors: - // that might cause cycles before Global has finished initialization. - BeanInfoAttr = rootMirror.getRequiredClass("scala.beans.BeanInfo") - - String_valueOf = { - getMember(StringModule, nme.valueOf) filter (sym => - sym.info.paramTypes match { - case List(pt) => pt.typeSymbol == ObjectClass - case _ => false - } - ) - } - - exemplar(JavaCloneableClass) - exemplar(JavaSerializableClass) - exemplar(SerializableClass) - - StringReference = exemplar(StringClass).c - StringBuilderReference = exemplar(StringBuilderClass).c - ThrowableReference = exemplar(ThrowableClass).c - jlCloneableReference = exemplar(JavaCloneableClass).c - jlNPEReference = exemplar(NullPointerExceptionClass).c - jioSerializableReference = exemplar(JavaSerializableClass).c - scalaSerializableReference = exemplar(SerializableClass).c - classCastExceptionReference = exemplar(ClassCastExceptionClass).c - - PartialFunctionReference = exemplar(PartialFunctionClass).c - for(idx <- 0 to definitions.MaxFunctionArity) { - FunctionReference(idx) = exemplar(FunctionClass(idx)) - AbstractFunctionReference(idx) = exemplar(AbstractFunctionClass(idx)) - abstractFunctionArityMap += (AbstractFunctionReference(idx).c -> idx) - AbstractPartialFunctionReference = exemplar(AbstractPartialFunctionClass).c - } - - BoxesRunTime = ClassBType("scala/runtime/BoxesRunTime") - } - - /* - * must-single-thread - */ - def clearBCodeTypes() { - symExemplars.clear() - exemplars.clear() - } - - val PublicStatic = asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_STATIC - val PublicStaticFinal = asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_STATIC | asm.Opcodes.ACC_FINAL - - val strMODULE_INSTANCE_FIELD = nme.MODULE_INSTANCE_FIELD.toString - - // ------------------------------------------------ - // accessory maps tracking the isInterface, innerClasses, superClass, and supportedInterfaces relations, - // allowing answering `conforms()` without resorting to typer. - // ------------------------------------------------ - - /** - * Type information for classBTypes. - * - * TODO rename Tracked - */ - val exemplars = new java.util.concurrent.ConcurrentHashMap[ClassBType, Tracked] - - /** - * Maps class symbols to their corresponding `Tracked` instance. - * - * This map is only used during the first backend phase (Worker1) where ClassDef trees are - * transformed into ClassNode asm trees. In this phase, ClassBTypes and their Tracked are created - * and added to the `exemplars` map. The `symExemplars` map is only used to know if a symbol has - * already been visited. - * - * TODO move this map to the builder class. it's only used during building. can be gc'd with the builder. - */ - val symExemplars = new java.util.concurrent.ConcurrentHashMap[Symbol, Tracked] - - /** - * A `Tracked` instance stores information about a BType. This allows ansering type questions - * without resolving to the compiler, in a thread-safe manner, in particular isSubtypeOf. - * - * @param c the BType described by this `Tracked` - * @param flags the java flags for the type, computed by BCodeTypes#javaFlags - * @param sc the bytecode-level superclass if any, null otherwise - * @param ifaces the interfaces explicitly declared. Not included are those transitively - * supported, but the utility method `allLeafIfaces()` can be used for that. - * @param innersChain the containing classes for a non-package-level class `c`, null otherwise. - * - * Note: the optimizer may inline anonymous closures, thus eliding those inner classes (no - * physical class file is emitted for elided classes). Before committing `innersChain` to - * bytecode, cross-check with the list of elided classes (SI-6546). - * - * All methods of this class can-multi-thread - * - * TODO @lry c: ClassBType. rename to ClassBTypeInfo - */ - case class Tracked(c: ClassBType, flags: Int, sc: Tracked, ifaces: Array[Tracked], innersChain: Array[InnerClassEntry]) { - - // not a case-field because we initialize it only for JVM classes we emit. - // TODO @lry make it an Option[List[BType]] - // TODO: this is currently not used. a commit in the optimizer branch uses this field to - // re-compute inner classes (ee4c185). leaving it in for now. - private var _directMemberClasses: List[BType] = null - - def directMemberClasses: List[BType] = { - assert(_directMemberClasses != null, s"getter directMemberClasses() invoked too early for $c") - _directMemberClasses - } - - def directMemberClasses_=(bs: List[BType]) { - if (_directMemberClasses != null) { - // TODO we enter here when both mirror class and plain class are emitted for the same ModuleClassSymbol. - assert(_directMemberClasses.sameElements(bs)) - } - _directMemberClasses = bs - } - - /* `isCompilingStdLib` saves the day when compiling: - * (1) scala.Nothing (the test `c.isNonSpecial` fails for it) - * (2) scala.Boolean (it has null superClass and is not an interface) - */ - assert(c.isNonSpecial || isCompilingStdLib /*(1)*/, s"non well-formed plain-type: $this") - assert( - if (sc == null) { (c == ObjectReference) || isInterface || isCompilingStdLib /*(2)*/ } - else { (c != ObjectReference) && !sc.isInterface } - , "non well-formed plain-type: " + this - ) - assert(ifaces.forall(i => i.c.isNonSpecial && i.isInterface), s"non well-formed plain-type: $this") - - import asm.Opcodes._ - def hasFlags(mask: Int) = (flags & mask) != 0 - def isInterface = hasFlags(ACC_INTERFACE) - def isFinal = hasFlags(ACC_FINAL) - def isInnerClass = { innersChain != null } - def isLambda = { - // ie isLCC || isTraditionalClosureClass - isFinal && (c.simpleName.contains(tpnme.ANON_FUN_NAME.toString)) && isFunctionType(c) - } - - /* can-multi-thread */ - def superClasses: List[Tracked] = { - if (sc == null) Nil else sc :: sc.superClasses - } - - /* can-multi-thread */ - def isSubtypeOf(other: BType): Boolean = { - assert(other.isNonSpecial, "so called special cases have to be handled in BCodeTypes.conforms()") - - if (c == other) return true; - - val otherIsIface = exemplars.get(other).isInterface - - if (this.isInterface) { - if (other == ObjectReference) return true; - if (!otherIsIface) return false; - } - else { - if (sc != null && sc.isSubtypeOf(other)) return true; - if (!otherIsIface) return false; - } - - var idx = 0 - while (idx < ifaces.length) { - if (ifaces(idx).isSubtypeOf(other)) return true; - idx += 1 - } - - false - } - - /* - * The `ifaces` field lists only those interfaces declared by `c` - * From the set of all supported interfaces, this method discards those which are supertypes of others in the set. - */ - def allLeafIfaces: Set[Tracked] = { - if (sc == null) { ifaces.toSet } - else { minimizeInterfaces(ifaces.toSet ++ sc.allLeafIfaces) } - } - - /* - * This type may not support in its entirety the interface given by the argument, however it may support some of its super-interfaces. - * We visualize each such supported subset of the argument's functionality as a "branch". This method returns all such branches. - * - * In other words, let Ri be a branch supported by `ib`, - * this method returns all Ri such that this <:< Ri, where each Ri is maximally deep. - */ - def supportedBranches(ib: Tracked): Set[Tracked] = { - assert(ib.isInterface, s"Non-interface argument: $ib") - - val result: Set[Tracked] = - if (this.isSubtypeOf(ib.c)) { Set(ib) } - else { ib.ifaces.toSet[Tracked].flatMap( bi => supportedBranches(bi) ) } - - checkAllInterfaces(result) - - result - } - - override def toString = { c.toString } - - } - - /* must-single-thread */ - final def isDeprecated(sym: Symbol): Boolean = { sym.annotations exists (_ matches definitions.DeprecatedAttr) } - - /* must-single-thread */ - final def hasInternalName(sym: Symbol) = sym.isClass || sym.isModuleNotMethod - - /* must-single-thread */ - def getSuperInterfaces(csym: Symbol): List[Symbol] = { - - // Additional interface parents based on annotations and other cues - def newParentForAttr(ann: AnnotationInfo): Symbol = ann.symbol match { - case definitions.RemoteAttr => definitions.RemoteInterfaceClass - case _ => NoSymbol - } - - /* Drop redundant interfaces (which are implemented by some other parent) from the immediate parents. - * In other words, no two interfaces in the result are related by subtyping. - * This method works on Symbols, a similar one (not duplicate) works on Tracked instances. - */ - def minimizeInterfaces(lstIfaces: List[Symbol]): List[Symbol] = { - var rest = lstIfaces - var leaves = List.empty[Symbol] - while (!rest.isEmpty) { - val candidate = rest.head - val nonLeaf = leaves exists { lsym => lsym isSubClass candidate } - if (!nonLeaf) { - leaves = candidate :: (leaves filterNot { lsym => candidate isSubClass lsym }) - } - rest = rest.tail - } - - leaves - } - - val superInterfaces0: List[Symbol] = csym.mixinClasses - val superInterfaces = existingSymbols(superInterfaces0 ++ csym.annotations.map(newParentForAttr)).distinct - - assert(!superInterfaces.contains(NoSymbol), s"found NoSymbol among: ${superInterfaces.mkString(", ")}") - assert(superInterfaces.forall(s => s.isInterface || s.isTrait), s"found non-interface among: ${superInterfaces.mkString(", ")}") - - minimizeInterfaces(superInterfaces) - } - - /* - * Records the superClass and supportedInterfaces relations, - * so that afterwards queries can be answered without resorting to typer. - * This method does not add to `innerClassBufferASM`, use `internalName()` or `asmType()` or `toTypeKind()` for that. - * On the other hand, this method does record the inner-class status of the argument, via `buildExemplar()`. - * - * must-single-thread - */ - final def exemplar(csym0: Symbol): Tracked = { - assert(csym0 != NoSymbol, "NoSymbol can't be tracked") - - val csym = { - if (csym0.isJavaDefined && csym0.isModuleClass) csym0.linkedClassOfClass - else if (csym0.isModule) csym0.moduleClass - else csym0 // we track only module-classes and plain-classes - } - - assert(!primitiveTypeMap.contains(csym) || isCompilingStdLib, s"primitive types not tracked here: ${csym.fullName}") - assert(!phantomTypeMap.contains(csym), s"phantom types not tracked here: ${csym.fullName}") - - val opt = symExemplars.get(csym) - if (opt != null) { - return opt - } - val key = new ClassBType(csym.javaBinaryName.toTypeName) - assert(key.isNonSpecial || isCompilingStdLib, s"Not a class to track: ${csym.fullName}") - - // TODO accomodate the fix for SI-5031 of https://github.com/scala/scala/commit/0527b2549bcada2fda2201daa630369b377d0877 - // TODO Weaken this assertion? buildExemplar() needs to be updated, too. In the meantime, pos/t5031_3 has been moved to test/disabled/pos. - val whatWasInExemplars = exemplars.get(key) - assert(whatWasInExemplars == null, "Maps `symExemplars` and `exemplars` got out of synch.") - val tr = buildExemplar(key, csym) - symExemplars.put(csym, tr) - if (csym != csym0) { symExemplars.put(csym0, tr) } - exemplars.put(tr.c, tr) // tr.c is the hash-consed, internalized, canonical representative for csym's key. - tr - } - - /* - * must-single-thread - */ - private def buildExemplar(key: ClassBType, csym: Symbol): Tracked = { - val sc = - if (csym.isImplClass) definitions.ObjectClass - else csym.superClass - assert( - if (csym == definitions.ObjectClass) - sc == NoSymbol - else if (csym.isInterface) - sc == definitions.ObjectClass - else - ((sc != NoSymbol) && !sc.isInterface) || isCompilingStdLib, - "superClass out of order" - ) - val ifacesArr = getSuperInterfaces(csym).map(exemplar).toArray - - val flags = mkFlags( - javaFlags(csym), - if (isDeprecated(csym)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo access flag - ) - - val tsc = if (sc == NoSymbol) null else exemplar(sc) - - val innersChain = saveInnerClassesFor(csym, key) - - Tracked(key, flags, tsc, ifacesArr, innersChain) - } - - // ---------------- utilities around interfaces represented by Tracked instances. ---------------- - - /* Drop redundant interfaces (those which are implemented by some other). - * In other words, no two interfaces in the result are related by subtyping. - * This method works on Tracked elements, a similar one (not duplicate) works on Symbols. - */ - def minimizeInterfaces(lstIfaces: Set[Tracked]): Set[Tracked] = { - checkAllInterfaces(lstIfaces) - var rest = lstIfaces.toList - var leaves = List.empty[Tracked] - while (!rest.isEmpty) { - val candidate = rest.head - val nonLeaf = leaves exists { leaf => leaf.isSubtypeOf(candidate.c) } - if (!nonLeaf) { - leaves = candidate :: (leaves filterNot { leaf => candidate.isSubtypeOf(leaf.c) }) - } - rest = rest.tail - } - - leaves.toSet - } - - def allInterfaces(is: Iterable[Tracked]): Boolean = { is forall { i => i.isInterface } } - def nonInterfaces(is: Iterable[Tracked]): Iterable[Tracked] = { is filterNot { i => i.isInterface } } - - def checkAllInterfaces(ifaces: Iterable[Tracked]) { - assert(allInterfaces(ifaces), s"Non-interfaces: ${nonInterfaces(ifaces).mkString}") - } - - /* - * Subtype check `a <:< b` on BTypes that takes into account the JVM built-in numeric promotions (e.g. BYTE to INT). - * Its operation can be visualized more easily in terms of the Java bytecode type hierarchy. - * This method used to be called, in the ICode world, TypeKind.<:<() - * - * can-multi-thread - */ - final def conforms(a: BType, b: BType): Boolean = { - if (a.isArray) { // may be null - /* Array subtyping is covariant here, as in Java bytecode. Also necessary for Java interop. */ - if ((b == jlCloneableReference) || - (b == jioSerializableReference) || - (b == AnyRefReference)) { true } - else if (b.isArray) { conforms(a.asArrayBType.componentType, // TODO @lry change to pattern match, get rid of casts - b.asArrayBType.componentType) } - else { false } - } - else if (a.isBoxed) { // may be null - if (b.isBoxed) { a == b } - else if (b == AnyRefReference) { true } - else if (!(b.isClass)) { false } - else { exemplars.get(a).isSubtypeOf(b) } // e.g., java/lang/Double conforms to java/lang/Number - } - else if (a.isNullType) { // known to be null - if (b.isNothingType) { false } - else if (b.isPrimitive) { false } - else { true } - } - else if (a.isNothingType) { // known to be Nothing - true - } - else if (a == UNIT) { - b == UNIT - } - else if (a.isClass) { // may be null - if (a.isNothingType) { true } - else if (b.isClass) { exemplars.get(a).isSubtypeOf(b) } - else if (b.isArray) { a.isNullType } // documentation only, because `if(a.isNullType)` (above) covers this case already. - else { false } - } - else { - - def msg = s"(a: $a, b: $b)" - - assert(a.isNonVoidPrimitiveType, s"a isn't a non-Unit value type. $msg") - assert(b.isPrimitive, s"b isn't a value type. $msg") - - (a eq b) || (a match { - case BOOL | BYTE | SHORT | CHAR => b == INT || b == LONG // TODO Actually, BOOL does NOT conform to LONG. Even with adapt(). - case _ => a == b - }) - } - } - - /* The maxValueType of (Char, Byte) and of (Char, Short) is Int, to encompass the negative values of Byte and Short. See ticket #2087. - * - * can-multi-thread - */ - def maxValueType(a: BType, other: BType): BType = { - assert(a.isPrimitive, "maxValueType() is defined only for 1st arg valuetypes (2nd arg doesn't matter).") - - def uncomparable: Nothing = { - abort(s"Uncomparable BTypes: $a with $other") - } - - if (a.isNothingType) return other; - if (other.isNothingType) return a; - if (a == other) return a; - - a match { - - case UNIT => uncomparable - case BOOL => uncomparable - - case BYTE => - if (other == CHAR) INT - else if (other.isNumericType) other - else uncomparable - - case SHORT => - other match { - case BYTE => SHORT - case CHAR => INT - case INT | LONG | FLOAT | DOUBLE => other - case _ => uncomparable - } - - case CHAR => - other match { - case BYTE | SHORT => INT - case INT | LONG | FLOAT | DOUBLE => other - case _ => uncomparable - } - - case INT => - other match { - case BYTE | SHORT | CHAR => INT - case LONG | FLOAT | DOUBLE => other - case _ => uncomparable - } - - case LONG => - if (other.isIntegralType) LONG - else if (other.isRealType) DOUBLE - else uncomparable - - case FLOAT => - if (other == DOUBLE) DOUBLE - else if (other.isNumericType) FLOAT - else uncomparable - - case DOUBLE => - if (other.isNumericType) DOUBLE - else uncomparable - - case _ => uncomparable - } - } - - /* Takes promotions of numeric primitives into account. - * - * can-multi-thread - */ - final def maxType(a: BType, other: BType): BType = { - if (a.isPrimitive) { maxValueType(a, other) } - else { - if (a.isNothingType) return other; - if (other.isNothingType) return a; - if (a == other) return a; - // Approximate `lub`. The common type of two references is always AnyRef. - // For 'real' least upper bound wrt to subclassing use method 'lub'. - assert(a.isArray || a.isBoxed || a.isClass, s"This is not a valuetype and it's not something else, what is it? $a") - // TODO For some reason, ICode thinks `REFERENCE(...).maxType(BOXED(whatever))` is `uncomparable`. Here, that has maxType AnyRefReference. - // BTW, when swapping arguments, ICode says BOXED(whatever).maxType(REFERENCE(...)) == AnyRefReference, so I guess the above was an oversight in REFERENCE.maxType() - if (other.isRef) { AnyRefReference } - else { abort(s"Uncomparable BTypes: $a with $other") } - } - } - - /* - * Whether the argument is a subtype of - * scala.PartialFunction[-A, +B] extends (A => B) - * N.B.: this method returns true for a scala.runtime.AbstractPartialFunction - * - * can-multi-thread - */ - def isPartialFunctionType(t: BType): Boolean = { - (t.isClass) && exemplars.get(t).isSubtypeOf(PartialFunctionReference) - } - - /* - * Whether the argument is a subtype of scala.FunctionX where 0 <= X <= definitions.MaxFunctionArity - * - * can-multi-thread - */ - def isFunctionType(t: BType): Boolean = { - if (!t.isClass) return false - var idx = 0 - val et: Tracked = exemplars.get(t) - while (idx <= definitions.MaxFunctionArity) { - if (et.isSubtypeOf(FunctionReference(idx).c)) { - return true - } - idx += 1 - } - false - } - - /** - * must-single-thread - * - * True for module classes of package level objects. The backend will generate a mirror class for - * such objects. - */ - def isTopLevelModuleClass(sym: Symbol): Boolean = exitingPickler { - // phase travel to pickler required for isNestedClass (looks at owner) - val r = sym.isModuleClass && !sym.isNestedClass - // The mixin phase adds the `lateMODULE` flag to trait implementation classes. Since the flag - // is late, it should not be visible here inside the time travel. We check this. - if (r) assert(!sym.isImplClass, s"isModuleClass should be false for impl class $sym") - r - } - - /** - * must-single-thread - * - * True for module classes of modules that are top-level or owned only by objects. Module classes - * for such objects will get a MODULE$ flag and a corresponding static initializer. - */ - def isStaticModuleClass(sym: Symbol): Boolean = { - /* The implementation of this method is tricky because it is a source-level property. Various - * phases changed the symbol's properties in the meantime. - * - * (1) Phase travel to to pickler is required to exclude implementation classes; they have the - * lateMODULEs after mixin, so isModuleClass would be true. - * - * (2) We cannot use `sym.isStatic` because lambdalift modified (destructively) the owner. For - * example, in - * object T { def f { object U } } - * the owner of U is T, so UModuleClass.isStatic is true. Phase travel does not help here. - * So we basically re-implement `sym.isStaticOwner`, but using the original owner chain. - */ - - def isOriginallyStaticOwner(sym: Symbol): Boolean = { - sym.isPackageClass || sym.isModuleClass && isOriginallyStaticOwner(sym.originalOwner) - } - - exitingPickler { // (1) - sym.isModuleClass && - isOriginallyStaticOwner(sym.originalOwner) // (2) - } - } - - - // --------------------------------------------------------------------- - // ---------------- InnerClasses attribute (JVMS 4.7.6) ---------------- - // --------------------------------------------------------------------- - - val INNER_CLASSES_FLAGS = - (asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_PRIVATE | asm.Opcodes.ACC_PROTECTED | - asm.Opcodes.ACC_STATIC | asm.Opcodes.ACC_INTERFACE | asm.Opcodes.ACC_ABSTRACT | asm.Opcodes.ACC_FINAL) - - /* - * @param name the internal name of an inner class. - * @param outerName the internal name of the class to which the inner class belongs. - * May be `null` for non-member inner classes (ie for a Java local class or a Java anonymous class). - * @param innerName the (simple) name of the inner class inside its enclosing class. It's `null` for anonymous inner classes. - * @param access the access flags of the inner class as originally declared in the enclosing class. - */ - case class InnerClassEntry(name: String, outerName: String, innerName: String, access: Int) { - assert(name != null, "Null isn't good as class name in an InnerClassEntry.") - } - - /* For given symbol return a symbol corresponding to a class that should be declared as inner class. - * - * For example: - * class A { - * class B - * object C - * } - * - * then method will return: - * NoSymbol for A, - * the same symbol for A.B (corresponding to A$B class), and - * A$C$ symbol for A.C. - * - * must-single-thread - */ - def innerClassSymbolFor(s: Symbol): Symbol = - if (s.isClass) s else if (s.isModule) s.moduleClass else NoSymbol - - /* - * Computes the chain of inner-class (over the is-member-of relation) for the given argument. - * The resulting chain will be cached in `exemplars`. - * - * The chain thus cached is valid during this compiler run, see in contrast - * `innerClassBufferASM` for a cache that is valid only for the class being emitted. - * - * The argument can be any symbol, but given that this method is invoked only from `buildExemplar()`, - * in practice it has been vetted to be a class-symbol. - * - * Returns: - * - * - a non-empty array of entries for an inner-class argument. - * The array's first element is the outermost top-level class, - * the array's last element corresponds to csym. - * - * - null otherwise. - * - * This method does not add to `innerClassBufferASM`, use instead `exemplar()` for that. - * - * must-single-thread - */ - final def saveInnerClassesFor(csym: Symbol, csymTK: BType): Array[InnerClassEntry] = { - - val ics = innerClassSymbolFor(csym) - if (ics == NoSymbol) { - return null - } - assert(ics == csym, s"Disagreement between innerClassSymbolFor() and exemplar()'s tracked symbol for the same input: ${csym.fullName}") - - var chain: List[Symbol] = Nil - var x = ics - while (x ne NoSymbol) { - assert(x.isClass, s"not a class symbol: ${x.fullName}") - // Uses `rawowner` because `owner` reflects changes in the owner chain due to flattening. - // The owner chain of a class only contains classes. This is because the lambdalift phase - // changes the `rawowner` destructively to point to the enclosing class. Before, the owner - // might be for example a method. - val isInner = !x.rawowner.isPackageClass - if (isInner) { - chain ::= x - x = innerClassSymbolFor(x.rawowner) - } else { - x = NoSymbol - } - } - - if (chain.isEmpty) null - else chain.map(toInnerClassEntry).toArray - } - - /* - * must-single-thread - */ - private def toInnerClassEntry(innerSym: Symbol): InnerClassEntry = { - - /* The outer name for this inner class. Note that it returns null - * when the inner class should not get an index in the constant pool. - * That means non-member classes (anonymous). See Section 4.7.5 in the JVMS. - */ - def outerName(innerSym: Symbol): Name = { - if (innerSym.originalEnclosingMethod != NoSymbol) - null - else { - val outerName = innerSym.rawowner.javaBinaryName - if (isTopLevelModuleClass(innerSym.rawowner)) nme.stripModuleSuffix(outerName) - else outerName - } - } - - def innerName(innerSym: Symbol): String = { - if (innerSym.isAnonymousClass || innerSym.isAnonymousFunction) - null - else - innerSym.rawname + innerSym.moduleSuffix - } - - // TODO @lry compare with table in spec: for example, deprecated should not be there it seems. - // http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.6-300-D.1-D.1 - // including "deprecated" was added in the initial commit of GenASM, but it was never in GenJVM. - val flags: Int = mkFlags( - // TODO @lry adding "static" whenever the class is owned by a module seems wrong. - // class C { object O { class I } } - // here, I is marked static in the InnerClass attribute. But the I constructor takes an outer instance. - // was added in 0469d41 - // what should it be? check what would make sense for java reflection. - // member of top-level object should be static? how about anonymous / local class that has - // been lifted to a top-level object? - // member that is only nested in objects should be static? - // verify: will ICodeReader still work after that? the code was introduced because of icode reader. - if (innerSym.rawowner.hasModuleFlag) asm.Opcodes.ACC_STATIC else 0, - javaFlags(innerSym), - if (isDeprecated(innerSym)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo-access flag - ) & (INNER_CLASSES_FLAGS | asm.Opcodes.ACC_DEPRECATED) - - val jname = innerSym.javaBinaryName.toString // never null - val oname = { // null when method-enclosed - val on = outerName(innerSym) - if (on == null) null else on.toString - } - val iname = { // null for anonymous inner class - val in = innerName(innerSym) - if (in == null) null else in.toString - } - - InnerClassEntry(jname, oname, iname, flags) - } - - // -------------------------------------------- - // ---------------- Java flags ---------------- - // -------------------------------------------- - - /* - * can-multi-thread - */ - final def hasPublicBitSet(flags: Int) = ((flags & asm.Opcodes.ACC_PUBLIC) != 0) - - /* - * must-single-thread - */ - final def isRemote(s: Symbol) = (s hasAnnotation definitions.RemoteAttr) - - /* - * Return the Java modifiers for the given symbol. - * Java modifiers for classes: - * - public, abstract, final, strictfp (not used) - * for interfaces: - * - the same as for classes, without 'final' - * for fields: - * - public, private (*) - * - static, final - * for methods: - * - the same as for fields, plus: - * - abstract, synchronized (not used), strictfp (not used), native (not used) - * - * (*) protected cannot be used, since inner classes 'see' protected members, - * and they would fail verification after lifted. - * - * must-single-thread - */ - def javaFlags(sym: Symbol): Int = { - // constructors of module classes should be private. introduced in b06edbc, probably to prevent - // creating module instances from java. for nested modules, the constructor needs to be public - // since they are created by the outer class and stored in a field. a java client can create - // new instances via outerClassInstance.new InnerModuleClass$(). - // TODO: do this early, mark the symbol private. - val privateFlag = - sym.isPrivate || (sym.isPrimaryConstructor && isTopLevelModuleClass(sym.owner)) - - // Symbols marked in source as `final` have the FINAL flag. (In the past, the flag was also - // added to modules and module classes, not anymore since 296b706). - // Note that the presence of the `FINAL` flag on a symbol does not correspond 1:1 to emitting - // ACC_FINAL in bytecode. - // - // Top-level modules are marked ACC_FINAL in bytecode (even without the FINAL flag). Nested - // objects don't get the flag to allow overriding (under -Yoverride-objects, SI-5676). - // - // For fields, only eager val fields can receive ACC_FINAL. vars or lazy vals can't: - // Source: http://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html#jls-17.5.3 - // "Another problem is that the specification allows aggressive - // optimization of final fields. Within a thread, it is permissible to - // reorder reads of a final field with those modifications of a final - // field that do not take place in the constructor." - // - // A var or lazy val which is marked final still has meaning to the - // scala compiler. The word final is heavily overloaded unfortunately; - // for us it means "not overridable". At present you can't override - // vars regardless; this may change. - // - // The logic does not check .isFinal (which checks flags for the FINAL flag, - // and includes symbols marked lateFINAL) instead inspecting rawflags so - // we can exclude lateFINAL. Such symbols are eligible for inlining, but to - // avoid breaking proxy software which depends on subclassing, we do not - // emit ACC_FINAL. - - val finalFlag = ( - (((sym.rawflags & symtab.Flags.FINAL) != 0) || isTopLevelModuleClass(sym)) - && !sym.enclClass.isInterface - && !sym.isClassConstructor - && !sym.isMutable // lazy vals and vars both - ) - - // Primitives are "abstract final" to prohibit instantiation - // without having to provide any implementations, but that is an - // illegal combination of modifiers at the bytecode level so - // suppress final if abstract if present. - import asm.Opcodes._ - mkFlags( - if (privateFlag) ACC_PRIVATE else ACC_PUBLIC, - if (sym.isDeferred || sym.hasAbstractFlag) ACC_ABSTRACT else 0, - if (sym.isInterface) ACC_INTERFACE else 0, - if (finalFlag && !sym.hasAbstractFlag) ACC_FINAL else 0, - if (sym.isStaticMember) ACC_STATIC else 0, - if (sym.isBridge) ACC_BRIDGE | ACC_SYNTHETIC else 0, - if (sym.isArtifact) ACC_SYNTHETIC else 0, - if (sym.isClass && !sym.isInterface) ACC_SUPER else 0, - if (sym.hasEnumFlag) ACC_ENUM else 0, - if (sym.isVarargsMethod) ACC_VARARGS else 0, - if (sym.hasFlag(symtab.Flags.SYNCHRONIZED)) ACC_SYNCHRONIZED else 0 - ) - // TODO @lry should probably also check / add "deprectated" - // all call sites of "javaFlags" seem to check for deprecation rigth after. - // Exception: the call below in javaFieldFlags. However, the caller of javaFieldFlags then - // does the check. - } - - /* - * must-single-thread - */ - def javaFieldFlags(sym: Symbol) = { - javaFlags(sym) | mkFlags( - if (sym hasAnnotation definitions.TransientAttr) asm.Opcodes.ACC_TRANSIENT else 0, - if (sym hasAnnotation definitions.VolatileAttr) asm.Opcodes.ACC_VOLATILE else 0, - if (sym.isMutable) 0 else asm.Opcodes.ACC_FINAL - ) - } - -} // end of class BCodeTypes diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala index 15bc0685336c..390de5fae1dc 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala @@ -1,37 +1,51 @@ +/* NSC -- new Scala compiler + * Copyright 2005-2014 LAMP/EPFL + * @author Martin Odersky + */ + package scala.tools.nsc package backend.jvm -import scala.collection.immutable -import scala.annotation.switch import scala.tools.asm import asm.Opcodes -import scala.collection.mutable.ListBuffer /** - * BTypes is a backend component that defines the class BType, a number of basic instances and - * some utilities. + * The BTypes component defines The BType class hierarchy. BTypes encapsulates all type information + * that is required after building the ASM nodes. This includes optimizations, geneartion of + * InnerClass attributes and generation of stack map frames. * - * A BType is essentially an slice of the array `chrs` denoting the name of the type, and a field - * denoting the kind (object, array, method, or one of the primitive types). - * - * BTypes depends on Global just because it re-uses hash-consing of Name. It would be cleaner to - * create an interface for BTypeName and extend it in scala.reflect.internal.Names#Name, that - * would simplify testing BTypes (no Global needed). + * This representation is immutable and independent of the compiler data structures, hence it can + * be queried by concurrent threads. */ -abstract class BTypes[G <: Global](val __global_dont_use: G) { - def chrs: Array[Char] +abstract class BTypes { + /** + * A map from internal names to ClassBTypes. Every ClassBType is added to this map on its + * construction. + * + * This map is used when computing stack map frames. The asm.ClassWriter invokes the method + * `getCommonSuperClass`. In this method we need to obtain the ClassBType for a given internal + * name. The method assumes that every class type that appears in the bytecode exists in the map. + * + * Concurrent because stack map frames are computed when in the class writer, which might run + * on multiple classes concurrently. + */ + protected val classBTypeFromInternalNameMap: collection.concurrent.Map[String, ClassBType] /** - * Interface for names stored in `chrs` + * The string represented by the `offset` / `length` values of a ClassBType, see comment of that + * class. */ - type BTypeName <: __global_dont_use.Name + protected def internalNameString(offset: Int, lenght: Int): String /** - * Create a new name in `chrs`. Names are assumed to be hash-consed. Equality on BType will use - * reference equality to compare the names. + * Obtain a previously constructed ClassBType for a given internal name. */ - def createNewName(s: String): BTypeName + def classBTypeFromInternalName(internalName: String) = classBTypeFromInternalNameMap(internalName) + /** + * A BType is either a primitve type, a ClassBType, an ArrayBType of one of these, or a MethodType + * referring to BTypes. + */ /*sealed*/ trait BType { // Not sealed for now due to SI-8546 final override def toString: String = this match { case UNIT => "V" @@ -73,18 +87,11 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { final def isMethod: Boolean = this.isInstanceOf[MethodBType] final def isNonVoidPrimitiveType = isPrimitive && this != UNIT - // TODO @lry should also include !isMethod in isNonSpecial? in this case it would be equivalent to isClass, so we could get rid of it. - final def isNonSpecial = !isPrimitive && !isArray && !isPhantomType - final def isNullType = this == RT_NULL || this == CT_NULL - final def isNothingType = this == RT_NOTHING || this == CT_NOTHING - final def isPhantomType = isNullType || isNothingType - - final def isBoxed = this match { - case BOXED_UNIT | BOXED_BOOLEAN | BOXED_CHAR | - BOXED_BYTE | BOXED_SHORT | BOXED_INT | - BOXED_FLOAT | BOXED_LONG | BOXED_DOUBLE => true - case _ => false - } + + final def isNullType = this == RT_NULL + final def isNothingType = this == RT_NOTHING + + final def isBoxed = this.isClass && boxedClasses(this.asClassBType) final def isIntSizedType = this == BOOL || this == CHAR || this == BYTE || this == SHORT || this == INT @@ -94,6 +101,72 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { final def isNumericType = isIntegralType || isRealType final def isWideType = size == 2 + /* + * Subtype check `this <:< other` on BTypes that takes into account the JVM built-in numeric + * promotions (e.g. BYTE to INT). Its operation can be visualized more easily in terms of the + * Java bytecode type hierarchy. + */ + final def conformsTo(other: BType): Boolean = { + assert(isRef || isPrimitive, s"conformsTo cannot handle $this") + assert(other.isRef || other.isPrimitive, s"conformsTo cannot handle $other") + + this match { + case ArrayBType(component) => + if (other == ObjectReference || other == jlCloneableReference || other == jioSerializableReference) true + else other match { + case ArrayBType(otherComponoent) => component.conformsTo(otherComponoent) + case _ => false + } + + case classType: ClassBType => + if (isBoxed) { + if (other.isBoxed) this == other + else if (other == ObjectReference) true + else other match { + case otherClassType: ClassBType => classType.isSubtypeOf(otherClassType) // e.g., java/lang/Double conforms to java/lang/Number + case _ => false + } + } else if (isNullType) { + if (other.isNothingType) false + else if (other.isPrimitive) false + else true // Null conforms to all classes (except Nothing) and arrays. + } else if (isNothingType) { + true + } else other match { + case otherClassType: ClassBType => classType.isSubtypeOf(otherClassType) + // case ArrayBType(_) => this.isNullType // documentation only, because `if (isNullType)` above covers this case + case _ => + // isNothingType || // documentation only, because `if (isNothingType)` above covers this case + false + } + + case UNIT => + other == UNIT + case BOOL | BYTE | SHORT | CHAR => + this == other || other == INT || other == LONG // TODO Actually, BOOL does NOT conform to LONG. Even with adapt(). + case _ => + assert(isPrimitive && other.isPrimitive, s"Expected primitive types $this - $other") + this == other + } + } + + /** + * Compute the upper bound of two types. + * Takes promotions of numeric primitives into account. + */ + final def maxType(other: BType): BType = this match { + case pt: PrimitiveBType => pt.maxValueType(other) + + case _: ArrayBType | _: ClassBType => + if (isNothingType) return other + if (other.isNothingType) return this + if (this == other) return this + + assert(other.isRef, s"Cannot compute maxType: $this, $other") + // Approximate `lub`. The common type of two references is always ObjectReference. + ObjectReference + } + /** * See documentation of [[typedOpcode]]. * The numbers are taken from asm.Type.VOID_TYPE ff., the values are those shifted by << 8. @@ -165,45 +238,77 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { case m: MethodBType => asm.Type.getMethodType(m.descriptor) } - def asRefBType : RefBType = this.asInstanceOf[RefBType] - def asArrayBType: ArrayBType = this.asInstanceOf[ArrayBType] - def asClassBType: ClassBType = this.asInstanceOf[ClassBType] + def asRefBType : RefBType = this.asInstanceOf[RefBType] + def asArrayBType : ArrayBType = this.asInstanceOf[ArrayBType] + def asClassBType : ClassBType = this.asInstanceOf[ClassBType] + def asPrimitiveBType : PrimitiveBType = this.asInstanceOf[PrimitiveBType] } - object BType { + sealed trait PrimitiveBType extends BType { + /** - * @param chars The character array containing the descriptor - * @param start The position where the descriptor starts - * @return The BType and the index of the first character after the consumed descriptor + * The upper bound of two primitive types. The `other` type has to be either a primitive + * type or Nothing. + * + * The maxValueType of (Char, Byte) and of (Char, Short) is Int, to encompass the negative + * values of Byte and Short. See ticket #2087. */ - private[BTypes] def fromNonMethodDescriptor(chars: Array[Char], start: Int): (BType, Int) = { - chars(start) match { - case 'L' => - var i = start - while (chars(i) != ';') { i += 1 } - // Example: chars = "IILpkg/Cls;I" - // ^ ^ - // start=2 i=10 - // `start + 1` to exclude the 'L', `i - start - 1` excludes the ';' - (new ClassBType(new String(chars, start + 1, i - start - 1)), i + 1) - case '[' => - val (res, next) = fromNonMethodDescriptor(chars, start + 1) - (ArrayBType(res), next) - case 'V' => (UNIT, start + 1) - case 'Z' => (BOOL, start + 1) - case 'C' => (CHAR, start + 1) - case 'B' => (BYTE, start + 1) - case 'S' => (SHORT, start + 1) - case 'I' => (INT, start + 1) - case 'F' => (FLOAT, start + 1) - case 'J' => (LONG, start + 1) - case 'D' => (DOUBLE, start + 1) + final def maxValueType(other: BType): BType = { + + def uncomparable: Nothing = throw new AssertionError(s"Cannot compute maxValueType: $this, $other") + + if (!other.isPrimitive && !other.isNothingType) uncomparable + + if (other.isNothingType) return this + if (this == other) return this + + this match { + case BYTE => + if (other == CHAR) INT + else if (other.isNumericType) other + else uncomparable + + case SHORT => + other match { + case BYTE => SHORT + case CHAR => INT + case INT | LONG | FLOAT | DOUBLE => other + case _ => uncomparable + } + + case CHAR => + other match { + case BYTE | SHORT => INT + case INT | LONG | FLOAT | DOUBLE => other + case _ => uncomparable + } + + case INT => + other match { + case BYTE | SHORT | CHAR => INT + case LONG | FLOAT | DOUBLE => other + case _ => uncomparable + } + + case LONG => + if (other.isIntegralType) LONG + else if (other.isRealType) DOUBLE + else uncomparable + + case FLOAT => + if (other == DOUBLE) DOUBLE + else if (other.isNumericType) FLOAT + else uncomparable + + case DOUBLE => + if (other.isNumericType) DOUBLE + else uncomparable + + case UNIT | BOOL => uncomparable } } } - sealed trait PrimitiveBType extends BType - case object UNIT extends PrimitiveBType case object BOOL extends PrimitiveBType case object CHAR extends PrimitiveBType @@ -261,6 +366,14 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { * - instance initializer: exectued when class is initialized (instance creation, static * field access, ...) * + * - A static nested class can be defined as + * - a static member class (explicitly static), or + * - a member class of an interface (implicitly static) + * - local classes are never static, even if they are defined in a static method. + * + * Note: it is NOT the case that all inner classes (non-static) have an outer pointer. Example: + * class C { static void foo { class D {} } } + * The class D is an inner class (non-static), but javac does not add an outer pointer to it. * * InnerClass * ---------- @@ -271,8 +384,8 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { * The JLS 13.1, points 9. / 10. requires: a class must reference (in the CP) * - its immediately enclosing class * - all of its member classes - * - all local and anonymous classes that appear elsewhere (method, constructor, initializer - * block, field initializer) + * - all local and anonymous classes that are referenced (or declared) elsewhere (method, + * constructor, initializer block, field initializer) * * In a comment, the 4.7.6 spec says: this implies an entry in the InnerClass attribute for * - All enclosing classes (except the outermost, which is top-level) @@ -432,64 +545,177 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { */ /** - * Class or Interface type. - * - * The information for creating a ClassBType (superClass, interfaces, etc) is obtained - * - either from a ClassSymbol, for classes being compiled or referenced from source (see - * BCodeTypes) - * - or, during inlining, from ASM ClassNodes that are parsed from class files. - * - * The class name is represented as a slice of the `chrs` array. This representation is efficient - * because the JVM class name is obtained through `classSymbol.javaBinaryName`. This already adds - * the necessary string to the `chrs` array, so it makes sense to reuse the same name table in the - * backend. - * - * Not a case class because that would expose the constructor that takes (offset, length) - * parameters (I didn't find a way to make it private, also the factory in the companion). - * - * @param offset See below - * @param length The class name is represented as offset and length in the `chrs` array. - * The (public) constructors of ClassBType take a BTypeName, which are - * hash-consed. This ensures that two ClassBType instances for the same name - * have the same offset and length. - * - * Not a case class because that would expose the (Int, Int) constructor (didn't find a way to - * make it private, also the factory in the companion). + * A ClassBType represents a class or interface type. The necessary information to build a + * ClassBType is extracted from compiler symbols and types, see BTypesFromSymbols. + * + * The `offset` and `length` fields are used to represent the internal name of the class. They + * are indices into some character array. The internal name can be obtained through the method + * `internalNameString`, which is abstract in this component. Name creation is assumed to be + * hash-consed, so if two ClassBTypes have the same internal name, they NEED to have the same + * `offset` and `length`. + * + * The actual implementation in subclass BTypesFromSymbols uses the global `chrs` array from the + * name table. This representation is efficient because the JVM class name is obtained through + * `classSymbol.javaBinaryName`. This already adds the necessary string to the `chrs` array, + * so it makes sense to reuse the same name table in the backend. + * + * ClassBType is not a case class because we want a custom equals method, and because the + * extractor extracts the internalName, which is what you typically need. */ - class ClassBType private(val offset: Int, val length: Int) extends RefBType { + final class ClassBType(val offset: Int, val length: Int) extends RefBType { /** - * Construct a ClassBType from the (intenred) internal name of a class. + * Write-once variable allows initializing a cyclic graph of infos. This is required for + * nested classes. Example: for the definition `class A { class B }` we have * - * @param internalName The internal name as a slice of the `chrs` array. The internal name does - * not have the surrounding 'L' and ';'. Note that - * `classSymbol.javaBinaryName` returns exactly such a name. + * B.info.nestedInfo.outerClass == A + * A.info.memberClasses contains B */ - def this(internalName: BTypeName) = this(internalName.start, internalName.length) + private var _info: ClassInfo = null - /** - * Construct a ClassBType from the internal name of a class. - * - * @param internalName The internal name of a class has the form "java/lang/String", without the - * surrounding 'L' and ';'. - */ - def this(internalName: String) = this({ - assert(!(internalName.head == 'L' && internalName.last == ';'), s"Descriptor instead of internal name: $internalName") - createNewName(internalName) - }) + def info: ClassInfo = { + assert(_info != null, s"ClassBType.info not yet assigned: $this") + _info + } + + def info_=(i: ClassInfo): Unit = { + assert(_info == null, s"Cannot set ClassBType.info multiple times: $this") + _info = i + checkInfoConsistency() + } + + classBTypeFromInternalNameMap(internalName) = this + + private def checkInfoConsistency(): Unit = { + // we assert some properties. however, some of the linked ClassBType (members, superClass, + // interfaces) may not yet have an `_info` (initialization of cyclic structures). so we do a + // best-effort verification. + def ifInit(c: ClassBType)(p: ClassBType => Boolean): Boolean = c._info == null || p(c) + + def isJLO(t: ClassBType) = t.internalName == "java/lang/Object" + + assert(!ClassBType.isInternalPhantomType(internalName), s"Cannot create ClassBType for phantom type $this") + + assert( + if (info.superClass.isEmpty) { isJLO(this) || (isCompilingPrimitive && ClassBType.hasNoSuper(internalName)) } + else if (isInterface) isJLO(info.superClass.get) + else !isJLO(this) && ifInit(info.superClass.get)(!_.isInterface), + s"Invalid superClass in $this: ${info.superClass}" + ) + assert( + info.interfaces.forall(c => ifInit(c)(_.isInterface)), + s"Invalid interfaces in $this: ${info.interfaces}" + ) + + assert(info.memberClasses.forall(c => ifInit(c)(_.isNestedClass)), info.memberClasses) + } /** * The internal name of a class is the string returned by java.lang.Class.getName, with all '.' * replaced by '/'. For example "java/lang/String". */ - def internalName: String = new String(chrs, offset, length) + def internalName: String = internalNameString(offset, length) /** * @return The class name without the package prefix */ def simpleName: String = internalName.split("/").last + def isInterface = (info.flags & asm.Opcodes.ACC_INTERFACE) != 0 + + def superClassesTransitive: List[ClassBType] = info.superClass match { + case None => Nil + case Some(sc) => sc :: sc.superClassesTransitive + } + + def isNestedClass = info.nestedInfo.isDefined + + def enclosingNestedClassesChain: List[ClassBType] = + if (isNestedClass) this :: info.nestedInfo.get.enclosingClass.enclosingNestedClassesChain + else Nil + + def innerClassAttributeEntry: Option[InnerClassEntry] = info.nestedInfo map { + case NestedInfo(_, outerName, innerName, isStaticNestedClass) => + InnerClassEntry( + internalName, + outerName.orNull, + innerName.orNull, + GenBCode.mkFlags( + info.flags, + if (isStaticNestedClass) asm.Opcodes.ACC_STATIC else 0 + ) & ClassBType.INNER_CLASSES_FLAGS + ) + } + + def isSubtypeOf(other: ClassBType): Boolean = { + if (this == other) return true + + if (isInterface) { + if (other == ObjectReference) return true // interfaces conform to Object + if (!other.isInterface) return false // this is an interface, the other is some class other than object. interfaces cannot extend classes, so the result is false. + // else: this and other are both interfaces. continue to (*) + } else { + val sc = info.superClass + if (sc.isDefined && sc.get.isSubtypeOf(other)) return true // the superclass of this class conforms to other + if (!other.isInterface) return false // this and other are both classes, and the superclass of this does not conform + // else: this is a class, the other is an interface. continue to (*) + } + + // (*) check if some interface of this class conforms to other. + info.interfaces.exists(_.isSubtypeOf(other)) + } + + /** + * Finding the least upper bound in agreement with the bytecode verifier + * Background: + * http://gallium.inria.fr/~xleroy/publi/bytecode-verification-JAR.pdf + * http://comments.gmane.org/gmane.comp.java.vm.languages/2293 + * https://issues.scala-lang.org/browse/SI-3872 + */ + def jvmWiseLUB(other: ClassBType): ClassBType = { + def isNotNullOrNothing(c: ClassBType) = !c.isNullType && !c.isNothingType + assert(isNotNullOrNothing(this) && isNotNullOrNothing(other), s"jvmWiseLub for null or nothing: $this - $other") + + val res: ClassBType = (this.isInterface, other.isInterface) match { + case (true, true) => + // exercised by test/files/run/t4761.scala + if (other.isSubtypeOf(this)) this + else if (this.isSubtypeOf(other)) other + else ObjectReference + + case (true, false) => + if (other.isSubtypeOf(this)) this else ObjectReference + + case (false, true) => + if (this.isSubtypeOf(other)) other else ObjectReference + + case _ => + // TODO @lry I don't really understand the reasoning here. + // Both this and other are classes. The code takes (transitively) all superclasses and + // finds the first common one. + firstCommonSuffix(this :: this.superClassesTransitive, other :: other.superClassesTransitive) + } + + assert(isNotNullOrNothing(res), s"jvmWiseLub computed: $res") + res + } + + private def firstCommonSuffix(as: List[ClassBType], bs: List[ClassBType]): ClassBType = { + var chainA = as + var chainB = bs + var fcs: ClassBType = null + do { + if (chainB contains chainA.head) fcs = chainA.head + else if (chainA contains chainB.head) fcs = chainB.head + else { + chainA = chainA.tail + chainB = chainB.tail + } + } while (fcs == null) + fcs + } + /** - * Custom equals / hashCode are needed because this is not a case class. + * Custom equals / hashCode: we only compare the name (offset / length) */ override def equals(o: Any): Boolean = (this eq o.asInstanceOf[Object]) || (o match { case c: ClassBType => c.offset == this.offset && c.length == this.length @@ -506,17 +732,87 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { } object ClassBType { - def apply(internalName: BTypeName): ClassBType = new ClassBType(internalName) - def apply(internalName: String): ClassBType = new ClassBType(internalName) - /** * Pattern matching on a ClassBType extracts the `internalName` of the class. */ def unapply(c: ClassBType): Option[String] = if (c == null) None else Some(c.internalName) + + /** + * Valid flags for InnerClass attribute entry. + * See http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.6 + */ + private val INNER_CLASSES_FLAGS = { + asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_PRIVATE | asm.Opcodes.ACC_PROTECTED | + asm.Opcodes.ACC_STATIC | asm.Opcodes.ACC_FINAL | asm.Opcodes.ACC_INTERFACE | + asm.Opcodes.ACC_ABSTRACT | asm.Opcodes.ACC_SYNTHETIC | asm.Opcodes.ACC_ANNOTATION | + asm.Opcodes.ACC_ENUM + } + + // Primitive classes have no super class. A ClassBType for those is only created when + // they are actually being compiled (e.g., when compiling scala/Boolean.scala). + private val hasNoSuper = Set( + "scala/Unit", + "scala/Boolean", + "scala/Char", + "scala/Byte", + "scala/Short", + "scala/Int", + "scala/Float", + "scala/Long", + "scala/Double" + ) + + private val isInternalPhantomType = Set( + "scala/Null", + "scala/Nothing" + ) } + /** + * The type info for a class. Used for symboltable-independent subtype checks in the backend. + * + * @param superClass The super class, not defined for class java/lang/Object. + * @param interfaces All transitively implemented interfaces, except for those inherited + * through the superclass. + * @param flags The java flags, obtained through `javaFlags`. Used also to derive + * the flags for InnerClass entries. + * @param memberClasses Classes nested in this class. Those need to be added to the + * InnerClass table, see the InnerClass spec summary above. + * @param nestedInfo If this describes a nested class, information for the InnerClass table. + */ + case class ClassInfo(superClass: Option[ClassBType], interfaces: List[ClassBType], flags: Int, + memberClasses: List[ClassBType], nestedInfo: Option[NestedInfo]) + + /** + * Information required to add a class to an InnerClass table. + * The spec summary above explains what information is required for the InnerClass entry. + * + * @param enclosingClass The enclosing class, if it is also nested. When adding a class + * to the InnerClass table, enclosing nested classes are also added. + * @param outerName The outerName field in the InnerClass entry, may be None. + * @param innerName The innerName field, may be None. + * @param isStaticNestedClass True if this is a static nested class (not inner class). + */ + case class NestedInfo(enclosingClass: ClassBType, + outerName: Option[String], + innerName: Option[String], + isStaticNestedClass: Boolean) + + /** + * This class holds the data for an entry in the InnerClass table. See the InnerClass summary + * above in this file. + * + * There's some overlap with the class NestedInfo, but it's not exactly the same and cleaner to + * keep separate. + * @param name The internal name of the class. + * @param outerName The internal name of the outer class, may be null. + * @param innerName The simple name of the inner class, may be null. + * @param flags The flags for this class in the InnerClass entry. + */ + case class InnerClassEntry(name: String, outerName: String, innerName: String, flags: Int) + case class ArrayBType(componentType: BType) extends RefBType { def dimension: Int = componentType match { case a: ArrayBType => 1 + a.dimension @@ -529,107 +825,27 @@ abstract class BTypes[G <: Global](val __global_dont_use: G) { } } - case class MethodBType(argumentTypes: List[BType], returnType: BType) extends BType { - private def this(types: (List[BType], BType)) = this(types._1, types._2) - def this(descriptor: String) = this(MethodBType.decomposeMethodDescriptor(descriptor)) - } - - object MethodBType { - private def decomposeMethodDescriptor(descriptor: String): (List[BType], BType) = { - val chars = descriptor.toCharArray - assert(chars(0) == '(', s"Not a valid method descriptor: $descriptor") - var i = 1 - val argTypes = new ListBuffer[BType] - while (chars(i) != ')') { - val (argType, next) = BType.fromNonMethodDescriptor(chars, i) - argTypes += argType - i = next - } - val (resType, _) = BType.fromNonMethodDescriptor(chars, i + 1) // `i + 1` to skip the ')' - (argTypes.toList, resType) - } - def apply(descriptor: String) = { - val (argTypes, resType) = decomposeMethodDescriptor(descriptor) - new MethodBType(argTypes, resType) - } - } + case class MethodBType(argumentTypes: List[BType], returnType: BType) extends BType - val BOXED_UNIT = ClassBType("java/lang/Void") - val BOXED_BOOLEAN = ClassBType("java/lang/Boolean") - val BOXED_BYTE = ClassBType("java/lang/Byte") - val BOXED_SHORT = ClassBType("java/lang/Short") - val BOXED_CHAR = ClassBType("java/lang/Character") - val BOXED_INT = ClassBType("java/lang/Integer") - val BOXED_LONG = ClassBType("java/lang/Long") - val BOXED_FLOAT = ClassBType("java/lang/Float") - val BOXED_DOUBLE = ClassBType("java/lang/Double") - - /* - * RT_NOTHING and RT_NULL exist at run-time only. They are the bytecode-level manifestation (in - * method signatures only) of what shows up as NothingClass resp. NullClass in Scala ASTs. - * - * Therefore, when RT_NOTHING or RT_NULL are to be emitted, a mapping is needed: the internal - * names of NothingClass and NullClass can't be emitted as-is. + /* Some definitions that are required for the implementation of BTypes. They are abstract because + * initializing them requires information from types / symbols, which is not accessible here in + * BTypes. + * + * They are defs (not vals) because they are implemented using vars (see comment on CoreBTypes). */ - val RT_NOTHING = ClassBType("scala/runtime/Nothing$") - val RT_NULL = ClassBType("scala/runtime/Null$") - val CT_NOTHING = ClassBType("scala/Nothing") - val CT_NULL = ClassBType("scala/Null") - - val srBooleanRef = ClassBType("scala/runtime/BooleanRef") - val srByteRef = ClassBType("scala/runtime/ByteRef") - val srCharRef = ClassBType("scala/runtime/CharRef") - val srIntRef = ClassBType("scala/runtime/IntRef") - val srLongRef = ClassBType("scala/runtime/LongRef") - val srFloatRef = ClassBType("scala/runtime/FloatRef") - val srDoubleRef = ClassBType("scala/runtime/DoubleRef") + + def boxedClasses: Set[ClassBType] + + def RT_NOTHING : ClassBType + def RT_NULL : ClassBType + + def ObjectReference : ClassBType + def jlCloneableReference : ClassBType + def jioSerializableReference : ClassBType /** - * Map from type kinds to the Java reference types. - * Useful when pushing class literals onto the operand stack (ldc instruction taking a class - * literal). - * @see Predef.classOf - * @see genConstant() - * - * TODO @lry rename to "boxedClassOfPrimitive" or so, check usages + * True if the current compilation unit is of a primitive class (scala.Boolean et al). + * Used only in assertions. Abstract here because its implementation depends on global. */ - val classLiteral = immutable.Map[BType, ClassBType]( - UNIT -> BOXED_UNIT, - BOOL -> BOXED_BOOLEAN, - BYTE -> BOXED_BYTE, - SHORT -> BOXED_SHORT, - CHAR -> BOXED_CHAR, - INT -> BOXED_INT, - LONG -> BOXED_LONG, - FLOAT -> BOXED_FLOAT, - DOUBLE -> BOXED_DOUBLE - ) - - case class MethodNameAndType(name: String, descriptor: String) - - val asmBoxTo: immutable.Map[BType, MethodNameAndType] = { - Map( - BOOL -> MethodNameAndType("boxToBoolean", "(Z)Ljava/lang/Boolean;" ) , - BYTE -> MethodNameAndType("boxToByte", "(B)Ljava/lang/Byte;" ) , - CHAR -> MethodNameAndType("boxToCharacter", "(C)Ljava/lang/Character;") , - SHORT -> MethodNameAndType("boxToShort", "(S)Ljava/lang/Short;" ) , - INT -> MethodNameAndType("boxToInteger", "(I)Ljava/lang/Integer;" ) , - LONG -> MethodNameAndType("boxToLong", "(J)Ljava/lang/Long;" ) , - FLOAT -> MethodNameAndType("boxToFloat", "(F)Ljava/lang/Float;" ) , - DOUBLE -> MethodNameAndType("boxToDouble", "(D)Ljava/lang/Double;" ) - ) - } - - val asmUnboxTo: immutable.Map[BType, MethodNameAndType] = { - Map( - BOOL -> MethodNameAndType("unboxToBoolean", "(Ljava/lang/Object;)Z") , - BYTE -> MethodNameAndType("unboxToByte", "(Ljava/lang/Object;)B") , - CHAR -> MethodNameAndType("unboxToChar", "(Ljava/lang/Object;)C") , - SHORT -> MethodNameAndType("unboxToShort", "(Ljava/lang/Object;)S") , - INT -> MethodNameAndType("unboxToInt", "(Ljava/lang/Object;)I") , - LONG -> MethodNameAndType("unboxToLong", "(Ljava/lang/Object;)J") , - FLOAT -> MethodNameAndType("unboxToFloat", "(Ljava/lang/Object;)F") , - DOUBLE -> MethodNameAndType("unboxToDouble", "(Ljava/lang/Object;)D") - ) - } + def isCompilingPrimitive: Boolean } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala new file mode 100644 index 000000000000..4043ed47b673 --- /dev/null +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala @@ -0,0 +1,384 @@ +/* NSC -- new Scala compiler + * Copyright 2005-2014 LAMP/EPFL + * @author Martin Odersky + */ + +package scala.tools.nsc +package backend.jvm + +import scala.tools.asm + +/** + * This class mainly contains the method classBTypeFromSymbol, which extracts the necessary + * information from a symbol and its type to create the correpsonding ClassBType. It requires + * access to the compiler (global parameter). + * + * The mixin CoreBTypes defines core BTypes that are used in the backend. Building these BTypes + * uses classBTypeFromSymbol, hence requires access to the compiler (global). + * + * BTypesFromSymbols extends BTypes because the implementation of BTypes requires access to some + * of the core btypes. They are declared in BTypes as abstract members. Note that BTypes does + * not have access to the compiler instance. + */ +class BTypesFromSymbols[G <: Global](val global: G) extends BTypes with CoreBTypes[G] { + import global._ + import definitions._ + + import global.TypeName + + def internalNameString(offset: Int, length: Int) = new String(global.chrs, offset, length) + + protected val classBTypeFromInternalNameMap = { + global.perRunCaches.recordCache(collection.concurrent.TrieMap.empty[String, ClassBType]) + } + + /** + * Cache for the method classBTypeFromSymbol. + */ + private val convertedClasses = perRunCaches.newMap[Symbol, ClassBType]() + + // helpers that need access to global. + // TODO @lry create a separate component, they don't belong to BTypesFromSymbols + + final val strMODULE_INSTANCE_FIELD = nme.MODULE_INSTANCE_FIELD.toString + + private val primitiveCompilationUnits = Set( + "Unit.scala", + "Boolean.scala", + "Char.scala", + "Byte.scala", + "Short.scala", + "Int.scala", + "Float.scala", + "Long.scala", + "Double.scala" + ) + + /** + * True if the current compilation unit is of a primitive class (scala.Boolean et al). + * Used only in assertions. + */ + def isCompilingPrimitive = { + primitiveCompilationUnits(currentUnit.source.file.name) + } + + def isCompilingArray = { + currentUnit.source.file.name == "Array.scala" + } + + // end helpers + + /** + * The ClassBType for a class symbol `sym`. + */ + final def classBTypeFromSymbol(classSym: Symbol): ClassBType = { + assert(classSym != NoSymbol, "Cannot create ClassBType from NoSymbol") + assert(classSym.isClass, s"Cannot create ClassBType from non-class symbol $classSym") + assert( + (!primitiveTypeMap.contains(classSym) || isCompilingPrimitive) && + (classSym != NothingClass && classSym != NullClass), + s"Cannot create ClassBType for special class symbol ${classSym.fullName}") + + convertedClasses.getOrElse(classSym, { + val internalName = classSym.javaBinaryName.toTypeName + // We first create and add the ClassBType to the hash map before computing its info. This + // allows initializing cylic dependencies, see the comment on variable ClassBType._info. + val classBType = new ClassBType(internalName.start, internalName.length) + convertedClasses(classSym) = classBType + setClassInfo(classSym, classBType) + }) + } + + private def setClassInfo(classSym: Symbol, classBType: ClassBType): ClassBType = { + val superClassSym = if (classSym.isImplClass) ObjectClass else classSym.superClass + assert( + if (classSym == ObjectClass) + superClassSym == NoSymbol + else if (classSym.isInterface) + superClassSym == ObjectClass + else + // A ClassBType for a primitive class (scala.Boolean et al) is only created when compiling these classes. + ((superClassSym != NoSymbol) && !superClassSym.isInterface) || (isCompilingPrimitive && primitiveTypeMap.contains(classSym)), + s"Bad superClass for $classSym: $superClassSym" + ) + val superClass = if (superClassSym == NoSymbol) None + else Some(classBTypeFromSymbol(superClassSym)) + + val interfaces = getSuperInterfaces(classSym).map(classBTypeFromSymbol) + + val flags = GenBCode.mkFlags( + javaFlags(classSym), + if (isDeprecated(classSym)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo access flag + ) + + def classOrModuleClass(sym: Symbol): Symbol = { + if (sym.isClass) sym + else if (sym.isModule) sym.moduleClass + else NoSymbol + } + + /* The InnerClass table must contain all nested classes. Local or anonymous classes (not + * members) are referenced from the emitted code of the class, so they are in innerClassBuffer. + * + * TODO @lry check the above. For example: class C { def foo = { class D; 0 } }, is D added? + * + * For member classes however, there might be no reference at all in the code of the class. + * The JMV spec still requires those classes to be added to the InnerClass table, so we collect + * them here. + */ + val memberClassSymbols = exitingErasure { + // time travel to a time before lambdalift (which lifts local classes up to the class, making them members) + for (sym <- List(classSym, classSym.linkedClassOfClass); + memberClass <- sym.info.decls.map(classOrModuleClass) if memberClass.isClass) + yield memberClass + } + + /** + * For nested java classes, the scala compiler creates both a class and a module (and therefore + * a module class) symbol. For example, in `class A { class B {} }`, the memberClassSymbols + * for A contain both the class B and the module class B. + * Here we get rid of the module class B, making sure that the class B is present. + */ + val memberClassSymbolsNoJavaModuleClasses = memberClassSymbols.filter(s => { + if (s.isJavaDefined && s.isModuleClass) { + // We could also search in memberClassSymbols for s.linkedClassOfClass, but sometimes that + // returns NoSymbol, so it doesn't work. + val nb = memberClassSymbols.count(mc => mc.name == s.name && mc.owner == s.owner) + assert(nb == 2, s"Java member module without member class: $s - $memberClassSymbols") + false + } else true + }) + + val memberClasses = memberClassSymbolsNoJavaModuleClasses.map(classBTypeFromSymbol) + + val nestedInfo = buildNestedInfo(classSym) + + classBType.info = ClassInfo(superClass, interfaces, flags, memberClasses, nestedInfo) + classBType + } + + /** + * All interfaces implemented by a class, except for those inherited through the superclass. + * + * TODO @lry share code with GenASM + */ + private def getSuperInterfaces(classSym: Symbol): List[Symbol] = { + + // Additional interface parents based on annotations and other cues + def newParentForAnnotation(ann: AnnotationInfo): Symbol = ann.symbol match { + case RemoteAttr => RemoteInterfaceClass + case _ => NoSymbol + } + + /** + * Drop redundant interfaces (which are implemented by some other parent) from the immediate + * parents. In other words, no two interfaces in the result are related by subtyping. + */ + def dropRedundantInterfaces(lstIfaces: List[Symbol]): List[Symbol] = { + var rest = lstIfaces + var leaves = List.empty[Symbol] + while (!rest.isEmpty) { + val candidate = rest.head + val nonLeaf = leaves exists { lsym => lsym isSubClass candidate } + if (!nonLeaf) { + leaves = candidate :: (leaves filterNot { lsym => candidate isSubClass lsym }) + } + rest = rest.tail + } + + leaves + } + + val superInterfaces0: List[Symbol] = classSym.mixinClasses + val superInterfaces = existingSymbols(superInterfaces0 ++ classSym.annotations.map(newParentForAnnotation)).distinct + + assert(!superInterfaces.contains(NoSymbol), s"found NoSymbol among: ${superInterfaces.mkString(", ")}") + assert(superInterfaces.forall(s => s.isInterface || s.isTrait), s"found non-interface among: ${superInterfaces.mkString(", ")}") + + dropRedundantInterfaces(superInterfaces) + } + + private def buildNestedInfo(innerClassSym: Symbol): Option[NestedInfo] = { + assert(innerClassSym.isClass, s"Cannot build NestedInfo for non-class symbol $innerClassSym") + + val isNested = !innerClassSym.rawowner.isPackageClass + if (!isNested) None + else { + // Phase travel to a time where the owner chain is in its original form. Example: + // object T { def f { class C } } + // C is an inner class (not a static nested class), see InnerClass summary in BTypes. + val isStaticNestedClass = enteringPickler(innerClassSym.isStatic) + + // After lambdalift (which is where we are), the rawowoner field contains the enclosing class. + val enclosingClassSym = { + if (innerClassSym.isJavaDefined && innerClassSym.rawowner.isModuleClass) { + // Example java source: class C { static class D { } } + // The Scala compiler creates a class and a module symbol for C. Because D is a static + // nested class, the symbol for D is nested in the module class C (not in the class C). + // For the InnerClass attribute, we use the class symbol C, which represents the situation + // in the source code. + assert(innerClassSym.isStatic, innerClassSym.rawowner) + innerClassSym.rawowner.linkedClassOfClass + } + else innerClassSym.rawowner + } + val enclosingClass: ClassBType = classBTypeFromSymbol(enclosingClassSym) + + val outerName: Option[String] = { + if (innerClassSym.originalEnclosingMethod != NoSymbol) { + None + } else { + val outerName = innerClassSym.rawowner.javaBinaryName + // Java compatibility. See the big comment in BTypes that summarizes the InnerClass spec. + val outerNameModule = if (isTopLevelModuleClass(innerClassSym.rawowner)) outerName.dropModule + else outerName + Some(outerNameModule.toString) + } + } + + val innerName: Option[String] = { + if (innerClassSym.isAnonymousClass || innerClassSym.isAnonymousFunction) None + else Some(innerClassSym.rawname + innerClassSym.moduleSuffix) // moduleSuffix for module classes + } + + Some(NestedInfo(enclosingClass, outerName, innerName, isStaticNestedClass)) + } + } + + /** + * True for module classes of package level objects. The backend will generate a mirror class for + * such objects. + */ + final def isTopLevelModuleClass(sym: Symbol): Boolean = exitingPickler { + // phase travel to pickler required for isNestedClass (looks at owner) + val r = sym.isModuleClass && !sym.isNestedClass + // The mixin phase adds the `lateMODULE` flag to trait implementation classes. Since the flag + // is late, it should not be visible here inside the time travel. We check this. + if (r) assert(!sym.isImplClass, s"isModuleClass should be false for impl class $sym") + r + } + + /** + * True for module classes of modules that are top-level or owned only by objects. Module classes + * for such objects will get a MODULE$ flag and a corresponding static initializer. + */ + final def isStaticModuleClass(sym: Symbol): Boolean = { + /* The implementation of this method is tricky because it is a source-level property. Various + * phases changed the symbol's properties in the meantime. + * + * (1) Phase travel to to pickler is required to exclude implementation classes; they have the + * lateMODULEs after mixin, so isModuleClass would be true. + * + * (2) We cannot use `sym.isStatic` because lambdalift modified (destructively) the owner. For + * example, in + * object T { def f { object U } } + * the owner of U is T, so UModuleClass.isStatic is true. Phase travel does not help here. + * So we basically re-implement `sym.isStaticOwner`, but using the original owner chain. + */ + + def isOriginallyStaticOwner(sym: Symbol): Boolean = { + sym.isPackageClass || sym.isModuleClass && isOriginallyStaticOwner(sym.originalOwner) + } + + exitingPickler { // (1) + sym.isModuleClass && + isOriginallyStaticOwner(sym.originalOwner) // (2) + } + } + + final def isDeprecated(sym: Symbol): Boolean = sym.annotations exists (_ matches DeprecatedAttr) + + // legacy, to be removed when the @remote annotation gets removed + final def isRemote(s: Symbol) = (s hasAnnotation definitions.RemoteAttr) + final def hasPublicBitSet(flags: Int) = ((flags & asm.Opcodes.ACC_PUBLIC) != 0) + + /** + * Return the Java modifiers for the given symbol. + * Java modifiers for classes: + * - public, abstract, final, strictfp (not used) + * for interfaces: + * - the same as for classes, without 'final' + * for fields: + * - public, private (*) + * - static, final + * for methods: + * - the same as for fields, plus: + * - abstract, synchronized (not used), strictfp (not used), native (not used) + * + * (*) protected cannot be used, since inner classes 'see' protected members, + * and they would fail verification after lifted. + */ + final def javaFlags(sym: Symbol): Int = { + // constructors of module classes should be private. introduced in b06edbc, probably to prevent + // creating module instances from java. for nested modules, the constructor needs to be public + // since they are created by the outer class and stored in a field. a java client can create + // new instances via outerClassInstance.new InnerModuleClass$(). + // TODO: do this early, mark the symbol private. + val privateFlag = + sym.isPrivate || (sym.isPrimaryConstructor && isTopLevelModuleClass(sym.owner)) + + // Symbols marked in source as `final` have the FINAL flag. (In the past, the flag was also + // added to modules and module classes, not anymore since 296b706). + // Note that the presence of the `FINAL` flag on a symbol does not correspond 1:1 to emitting + // ACC_FINAL in bytecode. + // + // Top-level modules are marked ACC_FINAL in bytecode (even without the FINAL flag). Nested + // objects don't get the flag to allow overriding (under -Yoverride-objects, SI-5676). + // + // For fields, only eager val fields can receive ACC_FINAL. vars or lazy vals can't: + // Source: http://docs.oracle.com/javase/specs/jls/se7/html/jls-17.html#jls-17.5.3 + // "Another problem is that the specification allows aggressive + // optimization of final fields. Within a thread, it is permissible to + // reorder reads of a final field with those modifications of a final + // field that do not take place in the constructor." + // + // A var or lazy val which is marked final still has meaning to the + // scala compiler. The word final is heavily overloaded unfortunately; + // for us it means "not overridable". At present you can't override + // vars regardless; this may change. + // + // The logic does not check .isFinal (which checks flags for the FINAL flag, + // and includes symbols marked lateFINAL) instead inspecting rawflags so + // we can exclude lateFINAL. Such symbols are eligible for inlining, but to + // avoid breaking proxy software which depends on subclassing, we do not + // emit ACC_FINAL. + + val finalFlag = ( + (((sym.rawflags & symtab.Flags.FINAL) != 0) || isTopLevelModuleClass(sym)) + && !sym.enclClass.isInterface + && !sym.isClassConstructor + && !sym.isMutable // lazy vals and vars both + ) + + // Primitives are "abstract final" to prohibit instantiation + // without having to provide any implementations, but that is an + // illegal combination of modifiers at the bytecode level so + // suppress final if abstract if present. + import asm.Opcodes._ + GenBCode.mkFlags( + if (privateFlag) ACC_PRIVATE else ACC_PUBLIC, + if (sym.isDeferred || sym.hasAbstractFlag) ACC_ABSTRACT else 0, + if (sym.isInterface) ACC_INTERFACE else 0, + if (finalFlag && !sym.hasAbstractFlag) ACC_FINAL else 0, + if (sym.isStaticMember) ACC_STATIC else 0, + if (sym.isBridge) ACC_BRIDGE | ACC_SYNTHETIC else 0, + if (sym.isArtifact) ACC_SYNTHETIC else 0, + if (sym.isClass && !sym.isInterface) ACC_SUPER else 0, + if (sym.hasEnumFlag) ACC_ENUM else 0, + if (sym.isVarargsMethod) ACC_VARARGS else 0, + if (sym.hasFlag(symtab.Flags.SYNCHRONIZED)) ACC_SYNCHRONIZED else 0 + ) + // TODO @lry should probably also check / add "deprectated" + // all call sites of "javaFlags" seem to check for deprecation rigth after. + // Exception: the call below in javaFieldFlags. However, the caller of javaFieldFlags then + // does the check. + } + + def javaFieldFlags(sym: Symbol) = { + javaFlags(sym) | GenBCode.mkFlags( + if (sym hasAnnotation TransientAttr) asm.Opcodes.ACC_TRANSIENT else 0, + if (sym hasAnnotation VolatileAttr) asm.Opcodes.ACC_VOLATILE else 0, + if (sym.isMutable) 0 else asm.Opcodes.ACC_FINAL + ) + } +} diff --git a/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala new file mode 100644 index 000000000000..d92e775185dd --- /dev/null +++ b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala @@ -0,0 +1,257 @@ +package scala.tools.nsc +package backend.jvm + +import scala.annotation.switch + +/** + * Core BTypes and some other definitions. The initialization of these definitions requies access + * to symbols / types (global). + * + * There is a reason for using vars instead of lazy vals. The symbols used to initialize the + * ClassBTypes may change from one compiler run to the next. To make sure the definitions are + * consistent with the symbols in the current run, the `intializeCoreBTypes` (which assigns the + * vars) is executed once for every compiler run. + * + * Note: if they were lazy vals, BType.classBTypeFromInternalNameMap could not be a perRunCache + * anymore: the classes defeined here need to be in that map, they are added when the ClassBTypes + * are created. The per run cache removes them, so they would be missing in the second run. + */ +trait CoreBTypes[G <: Global] { self: BTypesFromSymbols[G] => + import global._ + import rootMirror.{requiredClass, getClassIfDefined} + import definitions._ + + /** + * Maps primitive types to their corresponding PrimitiveBType. The map is defined lexically above + * the first use of `classBTypeFromSymbol` because that method looks at the map. + */ + var primitiveTypeMap: Map[Symbol, PrimitiveBType] = _ + + var BOXED_UNIT : ClassBType = _ + var BOXED_BOOLEAN : ClassBType = _ + var BOXED_BYTE : ClassBType = _ + var BOXED_SHORT : ClassBType = _ + var BOXED_CHAR : ClassBType = _ + var BOXED_INT : ClassBType = _ + var BOXED_LONG : ClassBType = _ + var BOXED_FLOAT : ClassBType = _ + var BOXED_DOUBLE : ClassBType = _ + + var boxedClasses: Set[ClassBType] = _ + + /** + * Map from primitive types to their boxed class type. Useful when pushing class literals onto the + * operand stack (ldc instruction taking a class literal), see genConstant. + */ + var boxedClassOfPrimitive: Map[PrimitiveBType, ClassBType] = _ + + /** + * Maps the method symbol for a box method to the boxed type of the result. For example, the + * method symbol for `Byte.box()` is mapped to the ClassBType `java/lang/Byte`. + */ + var boxResultType: Map[Symbol, ClassBType] = _ + + /** + * Maps the method symbol for an unbox method to the primitive type of the result. + * For example, the method symbol for `Byte.unbox()`) is mapped to the PrimitiveBType BYTE. */ + var unboxResultType: Map[Symbol, PrimitiveBType] = _ + + /* + * RT_NOTHING and RT_NULL exist at run-time only. They are the bytecode-level manifestation (in + * method signatures only) of what shows up as NothingClass resp. NullClass in Scala ASTs. + * + * Therefore, when RT_NOTHING or RT_NULL are to be emitted, a mapping is needed: the internal + * names of NothingClass and NullClass can't be emitted as-is. + */ + var RT_NOTHING : ClassBType = _ + var RT_NULL : ClassBType = _ + + var ObjectReference : ClassBType = _ + var objArrayReference : ArrayBType = _ + + var StringReference : ClassBType = _ + var StringBuilderReference : ClassBType = _ + var ThrowableReference : ClassBType = _ + var jlCloneableReference : ClassBType = _ + var jlNPEReference : ClassBType = _ + var jioSerializableReference : ClassBType = _ + var scalaSerializableReference : ClassBType = _ + var classCastExceptionReference : ClassBType = _ + + var srBooleanRef : ClassBType = _ + var srByteRef : ClassBType = _ + var srCharRef : ClassBType = _ + var srIntRef : ClassBType = _ + var srLongRef : ClassBType = _ + var srFloatRef : ClassBType = _ + var srDoubleRef : ClassBType = _ + + var hashMethodSym: Symbol = _ + + var AndroidParcelableInterface : Symbol = _ + var AndroidCreatorClass : Symbol = _ + + var BeanInfoAttr: Symbol = _ + + /* The Object => String overload. */ + var String_valueOf: Symbol = _ + + // scala.FunctionX and scala.runtim.AbstractFunctionX + var FunctionReference : Vector[ClassBType] = _ + var AbstractFunctionReference : Vector[ClassBType] = _ + var AbstractFunctionArityMap : Map[ClassBType, Int] = _ + + var PartialFunctionReference : ClassBType = _ + var AbstractPartialFunctionReference : ClassBType = _ + + var BoxesRunTime: ClassBType = _ + + case class MethodNameAndType(name: String, methodType: MethodBType) + + /** + * Methods in scala.runtime.BoxesRuntime + */ + var asmBoxTo : Map[BType, MethodNameAndType] = _ + var asmUnboxTo: Map[BType, MethodNameAndType] = _ + + var typeOfArrayOp: Map[Int, BType] = _ + + /** + * Initialize core ClassBTypes computed from symbols. Invoked once for each compiler run. + */ + def intializeCoreBTypes(): Unit = { + primitiveTypeMap = Map( + UnitClass -> UNIT, + BooleanClass -> BOOL, + CharClass -> CHAR, + ByteClass -> BYTE, + ShortClass -> SHORT, + IntClass -> INT, + LongClass -> LONG, + FloatClass -> FLOAT, + DoubleClass -> DOUBLE + ) + + BOXED_UNIT = classBTypeFromSymbol(requiredClass[java.lang.Void]) + BOXED_BOOLEAN = classBTypeFromSymbol(BoxedBooleanClass) + BOXED_BYTE = classBTypeFromSymbol(BoxedByteClass) + BOXED_SHORT = classBTypeFromSymbol(BoxedShortClass) + BOXED_CHAR = classBTypeFromSymbol(BoxedCharacterClass) + BOXED_INT = classBTypeFromSymbol(BoxedIntClass) + BOXED_LONG = classBTypeFromSymbol(BoxedLongClass) + BOXED_FLOAT = classBTypeFromSymbol(BoxedFloatClass) + BOXED_DOUBLE = classBTypeFromSymbol(BoxedDoubleClass) + + boxedClassOfPrimitive = Map( + UNIT -> BOXED_UNIT, + BOOL -> BOXED_BOOLEAN, + BYTE -> BOXED_BYTE, + SHORT -> BOXED_SHORT, + CHAR -> BOXED_CHAR, + INT -> BOXED_INT, + LONG -> BOXED_LONG, + FLOAT -> BOXED_FLOAT, + DOUBLE -> BOXED_DOUBLE + ) + + boxedClasses = boxedClassOfPrimitive.values.toSet + + boxResultType = { + for ((valueClassSym, boxMethodSym) <- currentRun.runDefinitions.boxMethod) + yield boxMethodSym -> boxedClassOfPrimitive(primitiveTypeMap(valueClassSym)) + } + + unboxResultType = { + for ((valueClassSym, unboxMethodSym) <- currentRun.runDefinitions.unboxMethod) + yield unboxMethodSym -> primitiveTypeMap(valueClassSym) + } + + // TODO @lry Once there's a 2.11.2 starr, use the commented argument list. The current starr crashes on the type literal `scala.runtime.Nothing$` + RT_NOTHING = classBTypeFromSymbol(rootMirror.getRequiredClass("scala.runtime.Nothing$")) // (requiredClass[scala.runtime.Nothing$]) + RT_NULL = classBTypeFromSymbol(rootMirror.getRequiredClass("scala.runtime.Null$")) // (requiredClass[scala.runtime.Null$]) + + ObjectReference = classBTypeFromSymbol(ObjectClass) + objArrayReference = ArrayBType(ObjectReference) + + StringReference = classBTypeFromSymbol(StringClass) + StringBuilderReference = classBTypeFromSymbol(StringBuilderClass) + ThrowableReference = classBTypeFromSymbol(ThrowableClass) + jlCloneableReference = classBTypeFromSymbol(JavaCloneableClass) // java/lang/Cloneable + jlNPEReference = classBTypeFromSymbol(NullPointerExceptionClass) // java/lang/NullPointerException + jioSerializableReference = classBTypeFromSymbol(JavaSerializableClass) // java/io/Serializable + scalaSerializableReference = classBTypeFromSymbol(SerializableClass) // scala/Serializable + classCastExceptionReference = classBTypeFromSymbol(ClassCastExceptionClass) // java/lang/ClassCastException + + srBooleanRef = classBTypeFromSymbol(requiredClass[scala.runtime.BooleanRef]) + srByteRef = classBTypeFromSymbol(requiredClass[scala.runtime.ByteRef]) + srCharRef = classBTypeFromSymbol(requiredClass[scala.runtime.CharRef]) + srIntRef = classBTypeFromSymbol(requiredClass[scala.runtime.IntRef]) + srLongRef = classBTypeFromSymbol(requiredClass[scala.runtime.LongRef]) + srFloatRef = classBTypeFromSymbol(requiredClass[scala.runtime.FloatRef]) + srDoubleRef = classBTypeFromSymbol(requiredClass[scala.runtime.DoubleRef]) + + hashMethodSym = getMember(ScalaRunTimeModule, nme.hash_) + + // TODO @lry avoiding going through through missingHook for every line in the REPL: https://github.com/scala/scala/commit/8d962ed4ddd310cc784121c426a2e3f56a112540 + AndroidParcelableInterface = getClassIfDefined("android.os.Parcelable") + AndroidCreatorClass = getClassIfDefined("android.os.Parcelable$Creator") + + BeanInfoAttr = requiredClass[scala.beans.BeanInfo] + + String_valueOf = { + getMember(StringModule, nme.valueOf) filter (sym => sym.info.paramTypes match { + case List(pt) => pt.typeSymbol == ObjectClass + case _ => false + }) + } + + // scala.FunctionX and scala.runtim.AbstractFunctionX + FunctionReference = (0 to MaxFunctionArity).map(i => classBTypeFromSymbol(FunctionClass(i)))(collection.breakOut) + + AbstractFunctionReference = (0 to MaxFunctionArity).map(i => classBTypeFromSymbol(AbstractFunctionClass(i)))(collection.breakOut) + + AbstractFunctionArityMap = AbstractFunctionReference.zipWithIndex.toMap + + PartialFunctionReference = classBTypeFromSymbol(PartialFunctionClass) + AbstractPartialFunctionReference = classBTypeFromSymbol(AbstractPartialFunctionClass) + + BoxesRunTime = classBTypeFromSymbol(requiredClass[scala.runtime.BoxesRunTime]) + + asmBoxTo = Map( + BOOL -> MethodNameAndType("boxToBoolean", MethodBType(List(BOOL), BOXED_BOOLEAN)), + BYTE -> MethodNameAndType("boxToByte", MethodBType(List(BYTE), BOXED_BYTE)), + CHAR -> MethodNameAndType("boxToCharacter", MethodBType(List(CHAR), BOXED_CHAR)), + SHORT -> MethodNameAndType("boxToShort", MethodBType(List(SHORT), BOXED_SHORT)), + INT -> MethodNameAndType("boxToInteger", MethodBType(List(INT), BOXED_INT)), + LONG -> MethodNameAndType("boxToLong", MethodBType(List(LONG), BOXED_LONG)), + FLOAT -> MethodNameAndType("boxToFloat", MethodBType(List(FLOAT), BOXED_FLOAT)), + DOUBLE -> MethodNameAndType("boxToDouble", MethodBType(List(DOUBLE), BOXED_DOUBLE)) + ) + + asmUnboxTo = Map( + BOOL -> MethodNameAndType("unboxToBoolean", MethodBType(List(ObjectReference), BOOL)), + BYTE -> MethodNameAndType("unboxToByte", MethodBType(List(ObjectReference), BYTE)), + CHAR -> MethodNameAndType("unboxToChar", MethodBType(List(ObjectReference), CHAR)), + SHORT -> MethodNameAndType("unboxToShort", MethodBType(List(ObjectReference), SHORT)), + INT -> MethodNameAndType("unboxToInt", MethodBType(List(ObjectReference), INT)), + LONG -> MethodNameAndType("unboxToLong", MethodBType(List(ObjectReference), LONG)), + FLOAT -> MethodNameAndType("unboxToFloat", MethodBType(List(ObjectReference), FLOAT)), + DOUBLE -> MethodNameAndType("unboxToDouble", MethodBType(List(ObjectReference), DOUBLE)) + ) + + typeOfArrayOp = { + import scalaPrimitives._ + Map( + (List(ZARRAY_LENGTH, ZARRAY_GET, ZARRAY_SET) map (_ -> BOOL)) ++ + (List(BARRAY_LENGTH, BARRAY_GET, BARRAY_SET) map (_ -> BYTE)) ++ + (List(SARRAY_LENGTH, SARRAY_GET, SARRAY_SET) map (_ -> SHORT)) ++ + (List(CARRAY_LENGTH, CARRAY_GET, CARRAY_SET) map (_ -> CHAR)) ++ + (List(IARRAY_LENGTH, IARRAY_GET, IARRAY_SET) map (_ -> INT)) ++ + (List(LARRAY_LENGTH, LARRAY_GET, LARRAY_SET) map (_ -> LONG)) ++ + (List(FARRAY_LENGTH, FARRAY_GET, FARRAY_SET) map (_ -> FLOAT)) ++ + (List(DARRAY_LENGTH, DARRAY_GET, DARRAY_SET) map (_ -> DOUBLE)) ++ + (List(OARRAY_LENGTH, OARRAY_GET, OARRAY_SET) map (_ -> ObjectReference)) : _* + ) + } + } +} diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala index 5494a827f4f2..480767f40774 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala @@ -46,6 +46,8 @@ import scala.tools.asm abstract class GenBCode extends BCodeSyncAndTry { import global._ + import bTypes._ + val phaseName = "jvm" override def newPhase(prev: Phase) = new BCodePhase(prev) @@ -272,7 +274,7 @@ abstract class GenBCode extends BCodeSyncAndTry { arrivalPos = 0 // just in case scalaPrimitives.init() - initBCodeTypes() + bTypes.intializeCoreBTypes() // initBytecodeWriter invokes fullName, thus we have to run it before the typer-dependent thread is activated. bytecodeWriter = initBytecodeWriter(cleanup.getEntryPoints) @@ -297,9 +299,6 @@ abstract class GenBCode extends BCodeSyncAndTry { * (2) if requested, check-java-signatures, over and beyond the syntactic checks in `getGenericSignature()` * */ - - // clearing maps - clearBCodeTypes() } /* @@ -385,3 +384,10 @@ abstract class GenBCode extends BCodeSyncAndTry { } // end of class BCodePhase } // end of class GenBCode + +object GenBCode { + def mkFlags(args: Int*) = args.foldLeft(0)(_ | _) + + final val PublicStatic = asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_STATIC + final val PublicStaticFinal = asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_STATIC | asm.Opcodes.ACC_FINAL +} diff --git a/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala b/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala index b592d065012b..cb7e7050b027 100644 --- a/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala +++ b/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala @@ -10,40 +10,39 @@ import org.junit.Assert._ @RunWith(classOf[JUnit4]) class BTypesTest { - val g: Global = new Global(new Settings()) + val settings = new Settings() + settings.processArgumentString("-usejavacp") + val g: Global = new Global(settings) + val run = new g.Run() // initializes some compiler internals + import g.{definitions => d, Symbol} - val btypes = new BTypes[g.type](g) { - def chrs = g.chrs - override type BTypeName = g.TypeName - override def createNewName(s: String) = g.newTypeName(s) - } + def duringBackend[T](f: => T) = g.exitingDelambdafy(f) + val btypes = new BTypesFromSymbols[g.type](g) import btypes._ + duringBackend(btypes.intializeCoreBTypes()) + + def classBTypeFromSymbol(sym: Symbol) = duringBackend(btypes.classBTypeFromSymbol(sym)) - val jls = "java/lang/String" - val jlo = "java/lang/Object" + val jlo = d.ObjectClass + val jls = d.StringClass - val o = ClassBType(jlo) - val s = ClassBType(jls) + val o = classBTypeFromSymbol(jlo) + val s = classBTypeFromSymbol(jls) val oArr = ArrayBType(o) val method = MethodBType(List(oArr, INT, DOUBLE, s), UNIT) @Test def classBTypesEquality() { - val s1 = ClassBType(jls) - val s2 = ClassBType(jls) - val o = ClassBType(jlo) + val s1 = classBTypeFromSymbol(jls) + val s2 = classBTypeFromSymbol(jls) + val o = classBTypeFromSymbol(jlo) assertEquals(s1, s2) assertEquals(s1.hashCode, s2.hashCode) assert(s1 != o) assert(s2 != o) } - @Test - def classBTypeRequiresInternalName() { - assertThrows[AssertionError](ClassBType(s"L$jls;"), _ contains "Descriptor instead of internal name") - } - @Test def typedOpcodes() { assert(UNIT.typedOpcode(Opcodes.IALOAD) == Opcodes.IALOAD) @@ -55,7 +54,7 @@ class BTypesTest { assert(FLOAT.typedOpcode(Opcodes.IALOAD) == Opcodes.FALOAD) assert(LONG.typedOpcode(Opcodes.IALOAD) == Opcodes.LALOAD) assert(DOUBLE.typedOpcode(Opcodes.IALOAD) == Opcodes.DALOAD) - assert(ClassBType(jls).typedOpcode(Opcodes.IALOAD) == Opcodes.AALOAD) + assert(classBTypeFromSymbol(jls).typedOpcode(Opcodes.IALOAD) == Opcodes.AALOAD) assert(UNIT.typedOpcode(Opcodes.IRETURN) == Opcodes.RETURN) assert(BOOL.typedOpcode(Opcodes.IRETURN) == Opcodes.IRETURN) @@ -66,7 +65,7 @@ class BTypesTest { assert(FLOAT.typedOpcode(Opcodes.IRETURN) == Opcodes.FRETURN) assert(LONG.typedOpcode(Opcodes.IRETURN) == Opcodes.LRETURN) assert(DOUBLE.typedOpcode(Opcodes.IRETURN) == Opcodes.DRETURN) - assert(ClassBType(jls).typedOpcode(Opcodes.IRETURN) == Opcodes.ARETURN) + assert(classBTypeFromSymbol(jls).typedOpcode(Opcodes.IRETURN) == Opcodes.ARETURN) } @Test @@ -84,21 +83,9 @@ class BTypesTest { } } + // TODO @lry do more tests @Test - def parseMethodDescriptorTest() { - val descriptors = List( - "()V", - "(ID)I", - "([[I[D)[D", - s"(L$jls;[L$jlo;)[[L$jls;", - s"(IL$jlo;)L$jls;" - ) - for (d <- descriptors) { - assertEquals(d, MethodBType(d).descriptor) - } + def maxTypeTest() { - // class types in method descriptor need surrounding 'L' and ';' - assertThrows[MatchError](MethodBType("(java/lang/String)V"), _ == "j (of class java.lang.Character)") - assertThrows[AssertionError](MethodBType("I"), _ contains "Not a valid method descriptor") } } From c3752d710eff34e348580bc093821a0a8170a325 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 1 Jul 2014 15:53:42 +0200 Subject: [PATCH 492/826] Add the ACC_DEPRECATED flag in javaFlags, instead of each call site. --- .../tools/nsc/backend/jvm/BCodeHelpers.scala | 5 +---- .../tools/nsc/backend/jvm/BCodeSkelBuilder.scala | 13 +++---------- .../nsc/backend/jvm/BTypesFromSymbols.scala | 16 +++++----------- 3 files changed, 9 insertions(+), 25 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala index e61be7411bee..5992a55ffa31 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala @@ -923,10 +923,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters { innerClassBufferASM.clear() - val flags = GenBCode.mkFlags( - javaFlags(cls), - if (isDeprecated(cls)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo access flag - ) + val flags = javaFlags(cls) val beanInfoName = (internalName(cls) + "BeanInfo") val beanInfoClass = new asm.tree.ClassNode diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala index 46399041451d..35a996262085 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala @@ -141,10 +141,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { classBType.internalName } - val flags = GenBCode.mkFlags( - javaFlags(claszSymbol), - if (isDeprecated(claszSymbol)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo access flag - ) + val flags = javaFlags(claszSymbol) val thisSignature = getGenericSignature(claszSymbol, claszSymbol.owner) cnode.visit(classfileVersion, flags, @@ -245,10 +242,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { */ for (f <- fieldSymbols(claszSymbol)) { val javagensig = getGenericSignature(f, claszSymbol) - val flags = GenBCode.mkFlags( - javaFieldFlags(f), - if (isDeprecated(f)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo access flag - ) + val flags = javaFieldFlags(f) val jfield = new asm.tree.FieldNode( flags, @@ -571,8 +565,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { javaFlags(methSymbol), if (claszSymbol.isInterface) asm.Opcodes.ACC_ABSTRACT else 0, if (methSymbol.isStrictFP) asm.Opcodes.ACC_STRICT else 0, - if (isNative) asm.Opcodes.ACC_NATIVE else 0, // native methods of objects are generated in mirror classes - if (isDeprecated(methSymbol)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo access flag + if (isNative) asm.Opcodes.ACC_NATIVE else 0 // native methods of objects are generated in mirror classes ) // TODO needed? for(ann <- m.symbol.annotations) { ann.symbol.initialize } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala index 4043ed47b673..783c9c56a16c 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala @@ -106,10 +106,7 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes with CoreBTyp val interfaces = getSuperInterfaces(classSym).map(classBTypeFromSymbol) - val flags = GenBCode.mkFlags( - javaFlags(classSym), - if (isDeprecated(classSym)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo access flag - ) + val flags = javaFlags(classSym) def classOrModuleClass(sym: Symbol): Symbol = { if (sym.isClass) sym @@ -286,8 +283,6 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes with CoreBTyp } } - final def isDeprecated(sym: Symbol): Boolean = sym.annotations exists (_ matches DeprecatedAttr) - // legacy, to be removed when the @remote annotation gets removed final def isRemote(s: Symbol) = (s hasAnnotation definitions.RemoteAttr) final def hasPublicBitSet(flags: Int) = ((flags & asm.Opcodes.ACC_PUBLIC) != 0) @@ -304,6 +299,8 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes with CoreBTyp * for methods: * - the same as for fields, plus: * - abstract, synchronized (not used), strictfp (not used), native (not used) + * for all: + * - deprecated * * (*) protected cannot be used, since inner classes 'see' protected members, * and they would fail verification after lifted. @@ -366,12 +363,9 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes with CoreBTyp if (sym.isClass && !sym.isInterface) ACC_SUPER else 0, if (sym.hasEnumFlag) ACC_ENUM else 0, if (sym.isVarargsMethod) ACC_VARARGS else 0, - if (sym.hasFlag(symtab.Flags.SYNCHRONIZED)) ACC_SYNCHRONIZED else 0 + if (sym.hasFlag(symtab.Flags.SYNCHRONIZED)) ACC_SYNCHRONIZED else 0, + if (sym.isDeprecated) asm.Opcodes.ACC_DEPRECATED else 0 ) - // TODO @lry should probably also check / add "deprectated" - // all call sites of "javaFlags" seem to check for deprecation rigth after. - // Exception: the call below in javaFieldFlags. However, the caller of javaFieldFlags then - // does the check. } def javaFieldFlags(sym: Symbol) = { From 53437e61305d656c115c94b25845c8f8dd7342ca Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 12 Aug 2014 16:58:44 +0200 Subject: [PATCH 493/826] Minor cleanups, integrating review feedback Review was in https://github.com/scala/scala/pull/3855 --- .../scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala | 2 +- src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala | 4 ++-- .../scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala | 2 -- 3 files changed, 3 insertions(+), 5 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index 542ff48c3366..05a2867a3a46 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -949,7 +949,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { def genCallMethod(method: Symbol, style: InvokeStyle, hostClass0: Symbol = null, pos: Position = NoPosition) { val siteSymbol = claszSymbol - val hostSymbol = if (hostClass0 == null) method.owner else hostClass0; + val hostSymbol = if (hostClass0 == null) method.owner else hostClass0 val methodOwner = method.owner // info calls so that types are up to date; erasure may add lateINTERFACE to traits hostSymbol.info ; methodOwner.info diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala index 5992a55ffa31..c14997628fbc 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala @@ -330,12 +330,12 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters { getClassBTypeAndRegisterInnerClass(classSym).internalName } - @inline private def assertClassNotArray(sym: Symbol): Unit = { + private def assertClassNotArray(sym: Symbol): Unit = { assert(sym.isClass, sym) assert(sym != definitions.ArrayClass || isCompilingArray, sym) } - @inline private def assertClassNotArrayNotPrimitive(sym: Symbol): Unit = { + private def assertClassNotArrayNotPrimitive(sym: Symbol): Unit = { assertClassNotArray(sym) assert(!primitiveTypeMap.contains(sym) || isCompilingPrimitive, sym) } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala index 783c9c56a16c..3b11a484bb37 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala @@ -24,8 +24,6 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes with CoreBTyp import global._ import definitions._ - import global.TypeName - def internalNameString(offset: Int, length: Int) = new String(global.chrs, offset, length) protected val classBTypeFromInternalNameMap = { From 22295833c33298064b40469a1ff0e491be5f80a1 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Wed, 13 Aug 2014 10:30:27 +0200 Subject: [PATCH 494/826] Integrate CoreBTypes by composition (not inheritance), non-var fields Make the fields of CoreBTypes non-variable. Instead, replace the CoreBTypes instance on each compiler run. That results in fewer variables, and the initialization code is directly where the fields are declared, instead of an init method. --- .../nsc/backend/jvm/BCodeBodyBuilder.scala | 1 + .../tools/nsc/backend/jvm/BCodeHelpers.scala | 1 + .../nsc/backend/jvm/BCodeIdiomatic.scala | 1 + .../nsc/backend/jvm/BCodeSkelBuilder.scala | 1 + .../nsc/backend/jvm/BCodeSyncAndTry.scala | 2 +- .../scala/tools/nsc/backend/jvm/BTypes.scala | 18 +- .../nsc/backend/jvm/BTypesFromSymbols.scala | 10 +- .../tools/nsc/backend/jvm/CoreBTypes.scala | 420 ++++++++++-------- .../tools/nsc/backend/jvm/GenBCode.scala | 1 + 9 files changed, 253 insertions(+), 202 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index 05a2867a3a46..2e629485a0a6 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -25,6 +25,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { import definitions._ import bCodeICodeCommon._ import bTypes._ + import coreBTypes._ /* * Functionality to build the body of ASM MethodNode, except for `synchronized` and `try` expressions. diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala index c14997628fbc..18a9bad1b7d3 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala @@ -21,6 +21,7 @@ import scala.tools.nsc.io.AbstractFile abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters { import global._ import bTypes._ + import coreBTypes._ /* * must-single-thread diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala index 290e899ba4d0..5d187168dbf5 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala @@ -25,6 +25,7 @@ abstract class BCodeIdiomatic extends SubComponent { import global._ import bTypes._ + import coreBTypes._ val classfileVersion: Int = settings.target.value match { case "jvm-1.5" => asm.Opcodes.V1_5 diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala index 35a996262085..3f3c0d062099 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala @@ -26,6 +26,7 @@ import java.io.PrintWriter abstract class BCodeSkelBuilder extends BCodeHelpers { import global._ import bTypes._ + import coreBTypes._ /* * There's a dedicated PlainClassBuilder for each CompilationUnit, diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala index c271e7b129e7..7c95b7fc3b5e 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSyncAndTry.scala @@ -21,7 +21,7 @@ import scala.tools.asm abstract class BCodeSyncAndTry extends BCodeBodyBuilder { import global._ import bTypes._ - + import coreBTypes._ /* * Functionality to lower `synchronized` and `try` expressions. diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala index 390de5fae1dc..389dbe43ebfe 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala @@ -42,6 +42,12 @@ abstract class BTypes { */ def classBTypeFromInternalName(internalName: String) = classBTypeFromInternalNameMap(internalName) + // Some core BTypes are required here, in class BType, where no Global instance is available. + // The Global is only available in the subclass BTypesFromSymbols. We cannot depend on the actual + // implementation (CoreBTypesProxy) here because it has members that refer to global.Symbol. + val coreBTypes: CoreBTypesProxyGlobalIndependent[this.type] + import coreBTypes._ + /** * A BType is either a primitve type, a ClassBType, an ArrayBType of one of these, or a MethodType * referring to BTypes. @@ -834,14 +840,10 @@ abstract class BTypes { * They are defs (not vals) because they are implemented using vars (see comment on CoreBTypes). */ - def boxedClasses: Set[ClassBType] - - def RT_NOTHING : ClassBType - def RT_NULL : ClassBType - - def ObjectReference : ClassBType - def jlCloneableReference : ClassBType - def jioSerializableReference : ClassBType + /** + * Just a named pair, used in CoreBTypes.asmBoxTo/asmUnboxTo. + */ + final case class MethodNameAndType(name: String, methodType: MethodBType) /** * True if the current compilation unit is of a primitive class (scala.Boolean et al). diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala index 3b11a484bb37..da3244ba2307 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala @@ -20,10 +20,18 @@ import scala.tools.asm * of the core btypes. They are declared in BTypes as abstract members. Note that BTypes does * not have access to the compiler instance. */ -class BTypesFromSymbols[G <: Global](val global: G) extends BTypes with CoreBTypes[G] { +class BTypesFromSymbols[G <: Global](val global: G) extends BTypes { import global._ import definitions._ + // Why the proxy, see documentation of class [[CoreBTypes]]. + val coreBTypes = new CoreBTypesProxy[this.type](this) + import coreBTypes._ + + final def intializeCoreBTypes(): Unit = { + coreBTypes.setBTypes(new CoreBTypes[this.type](this)) + } + def internalNameString(offset: Int, length: Int) = new String(global.chrs, offset, length) protected val classBTypeFromInternalNameMap = { diff --git a/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala index d92e775185dd..fac3c93be2d2 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala @@ -7,16 +7,27 @@ import scala.annotation.switch * Core BTypes and some other definitions. The initialization of these definitions requies access * to symbols / types (global). * - * There is a reason for using vars instead of lazy vals. The symbols used to initialize the - * ClassBTypes may change from one compiler run to the next. To make sure the definitions are - * consistent with the symbols in the current run, the `intializeCoreBTypes` (which assigns the - * vars) is executed once for every compiler run. + * The symbols used to initialize the ClassBTypes may change from one compiler run to the next. To + * make sure the definitions are consistent with the symbols in the current run, the + * `intializeCoreBTypes` method in BTypesFromSymbols creates a new instance of CoreBTypes in each + * compiler run. * - * Note: if they were lazy vals, BType.classBTypeFromInternalNameMap could not be a perRunCache - * anymore: the classes defeined here need to be in that map, they are added when the ClassBTypes - * are created. The per run cache removes them, so they would be missing in the second run. + * The class BTypesFromSymbols does not directly reference CoreBTypes, but CoreBTypesProxy. The + * reason is that having a `var bTypes: CoreBTypes` would not allow `import bTypes._`. Instead, the + * proxy class holds a `CoreBTypes` in a variable field and forwards to this instance. + * + * The definitions in `CoreBTypes` need to be lazy vals to break an initialization cycle. When + * creating a new instance to assign to the proxy, the `classBTypeFromSymbol` invoked in the + * constructor will actucally go through the proxy. The lazy vals make sure the instance is assigned + * in the proxy before the fields are initialized. + * + * Note: if we did not re-create the core BTypes on each compiler run, BType.classBTypeFromInternalNameMap + * could not be a perRunCache anymore: the classes defeined here need to be in that map, they are + * added when the ClassBTypes are created. The per run cache removes them, so they would be missing + * in the second run. */ -trait CoreBTypes[G <: Global] { self: BTypesFromSymbols[G] => +class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: Global]](val bTypes: BTFS) { + import bTypes._ import global._ import rootMirror.{requiredClass, getClassIfDefined} import definitions._ @@ -25,36 +36,62 @@ trait CoreBTypes[G <: Global] { self: BTypesFromSymbols[G] => * Maps primitive types to their corresponding PrimitiveBType. The map is defined lexically above * the first use of `classBTypeFromSymbol` because that method looks at the map. */ - var primitiveTypeMap: Map[Symbol, PrimitiveBType] = _ - - var BOXED_UNIT : ClassBType = _ - var BOXED_BOOLEAN : ClassBType = _ - var BOXED_BYTE : ClassBType = _ - var BOXED_SHORT : ClassBType = _ - var BOXED_CHAR : ClassBType = _ - var BOXED_INT : ClassBType = _ - var BOXED_LONG : ClassBType = _ - var BOXED_FLOAT : ClassBType = _ - var BOXED_DOUBLE : ClassBType = _ - - var boxedClasses: Set[ClassBType] = _ + lazy val primitiveTypeMap: Map[Symbol, PrimitiveBType] = Map( + UnitClass -> UNIT, + BooleanClass -> BOOL, + CharClass -> CHAR, + ByteClass -> BYTE, + ShortClass -> SHORT, + IntClass -> INT, + LongClass -> LONG, + FloatClass -> FLOAT, + DoubleClass -> DOUBLE + ) + + lazy val BOXED_UNIT : ClassBType = classBTypeFromSymbol(requiredClass[java.lang.Void]) + lazy val BOXED_BOOLEAN : ClassBType = classBTypeFromSymbol(BoxedBooleanClass) + lazy val BOXED_BYTE : ClassBType = classBTypeFromSymbol(BoxedByteClass) + lazy val BOXED_SHORT : ClassBType = classBTypeFromSymbol(BoxedShortClass) + lazy val BOXED_CHAR : ClassBType = classBTypeFromSymbol(BoxedCharacterClass) + lazy val BOXED_INT : ClassBType = classBTypeFromSymbol(BoxedIntClass) + lazy val BOXED_LONG : ClassBType = classBTypeFromSymbol(BoxedLongClass) + lazy val BOXED_FLOAT : ClassBType = classBTypeFromSymbol(BoxedFloatClass) + lazy val BOXED_DOUBLE : ClassBType = classBTypeFromSymbol(BoxedDoubleClass) /** * Map from primitive types to their boxed class type. Useful when pushing class literals onto the * operand stack (ldc instruction taking a class literal), see genConstant. */ - var boxedClassOfPrimitive: Map[PrimitiveBType, ClassBType] = _ + lazy val boxedClassOfPrimitive: Map[PrimitiveBType, ClassBType] = Map( + UNIT -> BOXED_UNIT, + BOOL -> BOXED_BOOLEAN, + BYTE -> BOXED_BYTE, + SHORT -> BOXED_SHORT, + CHAR -> BOXED_CHAR, + INT -> BOXED_INT, + LONG -> BOXED_LONG, + FLOAT -> BOXED_FLOAT, + DOUBLE -> BOXED_DOUBLE + ) + + lazy val boxedClasses: Set[ClassBType] = boxedClassOfPrimitive.values.toSet /** * Maps the method symbol for a box method to the boxed type of the result. For example, the * method symbol for `Byte.box()` is mapped to the ClassBType `java/lang/Byte`. */ - var boxResultType: Map[Symbol, ClassBType] = _ + lazy val boxResultType: Map[Symbol, ClassBType] = { + for ((valueClassSym, boxMethodSym) <- currentRun.runDefinitions.boxMethod) + yield boxMethodSym -> boxedClassOfPrimitive(primitiveTypeMap(valueClassSym)) + } /** * Maps the method symbol for an unbox method to the primitive type of the result. * For example, the method symbol for `Byte.unbox()`) is mapped to the PrimitiveBType BYTE. */ - var unboxResultType: Map[Symbol, PrimitiveBType] = _ + lazy val unboxResultType: Map[Symbol, PrimitiveBType] = { + for ((valueClassSym, unboxMethodSym) <- currentRun.runDefinitions.unboxMethod) + yield unboxMethodSym -> primitiveTypeMap(valueClassSym) + } /* * RT_NOTHING and RT_NULL exist at run-time only. They are the bytecode-level manifestation (in @@ -62,196 +99,195 @@ trait CoreBTypes[G <: Global] { self: BTypesFromSymbols[G] => * * Therefore, when RT_NOTHING or RT_NULL are to be emitted, a mapping is needed: the internal * names of NothingClass and NullClass can't be emitted as-is. + * TODO @lry Once there's a 2.11.3 starr, use the commented argument list. The current starr crashes on the type literal `scala.runtime.Nothing$` */ - var RT_NOTHING : ClassBType = _ - var RT_NULL : ClassBType = _ + lazy val RT_NOTHING : ClassBType = classBTypeFromSymbol(rootMirror.getRequiredClass("scala.runtime.Nothing$")) // (requiredClass[scala.runtime.Nothing$]) + lazy val RT_NULL : ClassBType = classBTypeFromSymbol(rootMirror.getRequiredClass("scala.runtime.Null$")) // (requiredClass[scala.runtime.Null$]) - var ObjectReference : ClassBType = _ - var objArrayReference : ArrayBType = _ + lazy val ObjectReference : ClassBType = classBTypeFromSymbol(ObjectClass) + lazy val objArrayReference : ArrayBType = ArrayBType(ObjectReference) - var StringReference : ClassBType = _ - var StringBuilderReference : ClassBType = _ - var ThrowableReference : ClassBType = _ - var jlCloneableReference : ClassBType = _ - var jlNPEReference : ClassBType = _ - var jioSerializableReference : ClassBType = _ - var scalaSerializableReference : ClassBType = _ - var classCastExceptionReference : ClassBType = _ + lazy val StringReference : ClassBType = classBTypeFromSymbol(StringClass) + lazy val StringBuilderReference : ClassBType = classBTypeFromSymbol(StringBuilderClass) + lazy val ThrowableReference : ClassBType = classBTypeFromSymbol(ThrowableClass) + lazy val jlCloneableReference : ClassBType = classBTypeFromSymbol(JavaCloneableClass) // java/lang/Cloneable + lazy val jlNPEReference : ClassBType = classBTypeFromSymbol(NullPointerExceptionClass) // java/lang/NullPointerException + lazy val jioSerializableReference : ClassBType = classBTypeFromSymbol(JavaSerializableClass) // java/io/Serializable + lazy val scalaSerializableReference : ClassBType = classBTypeFromSymbol(SerializableClass) // scala/Serializable + lazy val classCastExceptionReference : ClassBType = classBTypeFromSymbol(ClassCastExceptionClass) // java/lang/ClassCastException - var srBooleanRef : ClassBType = _ - var srByteRef : ClassBType = _ - var srCharRef : ClassBType = _ - var srIntRef : ClassBType = _ - var srLongRef : ClassBType = _ - var srFloatRef : ClassBType = _ - var srDoubleRef : ClassBType = _ + lazy val srBooleanRef : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.BooleanRef]) + lazy val srByteRef : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.ByteRef]) + lazy val srCharRef : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.CharRef]) + lazy val srIntRef : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.IntRef]) + lazy val srLongRef : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.LongRef]) + lazy val srFloatRef : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.FloatRef]) + lazy val srDoubleRef : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.DoubleRef]) - var hashMethodSym: Symbol = _ + lazy val hashMethodSym: Symbol = getMember(ScalaRunTimeModule, nme.hash_) - var AndroidParcelableInterface : Symbol = _ - var AndroidCreatorClass : Symbol = _ + // TODO @lry avoiding going through through missingHook for every line in the REPL: https://github.com/scala/scala/commit/8d962ed4ddd310cc784121c426a2e3f56a112540 + lazy val AndroidParcelableInterface : Symbol = getClassIfDefined("android.os.Parcelable") + lazy val AndroidCreatorClass : Symbol = getClassIfDefined("android.os.Parcelable$Creator") - var BeanInfoAttr: Symbol = _ + lazy val BeanInfoAttr: Symbol = requiredClass[scala.beans.BeanInfo] /* The Object => String overload. */ - var String_valueOf: Symbol = _ + lazy val String_valueOf: Symbol = { + getMember(StringModule, nme.valueOf) filter (sym => sym.info.paramTypes match { + case List(pt) => pt.typeSymbol == ObjectClass + case _ => false + }) + } // scala.FunctionX and scala.runtim.AbstractFunctionX - var FunctionReference : Vector[ClassBType] = _ - var AbstractFunctionReference : Vector[ClassBType] = _ - var AbstractFunctionArityMap : Map[ClassBType, Int] = _ - - var PartialFunctionReference : ClassBType = _ - var AbstractPartialFunctionReference : ClassBType = _ + lazy val FunctionReference : Vector[ClassBType] = (0 to MaxFunctionArity).map(i => classBTypeFromSymbol(FunctionClass(i)))(collection.breakOut) + lazy val AbstractFunctionReference : Vector[ClassBType] = (0 to MaxFunctionArity).map(i => classBTypeFromSymbol(AbstractFunctionClass(i)))(collection.breakOut) + lazy val AbstractFunctionArityMap : Map[ClassBType, Int] = AbstractFunctionReference.zipWithIndex.toMap - var BoxesRunTime: ClassBType = _ + lazy val PartialFunctionReference : ClassBType = classBTypeFromSymbol(PartialFunctionClass) + lazy val AbstractPartialFunctionReference : ClassBType = classBTypeFromSymbol(AbstractPartialFunctionClass) - case class MethodNameAndType(name: String, methodType: MethodBType) + lazy val BoxesRunTime: ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.BoxesRunTime]) /** * Methods in scala.runtime.BoxesRuntime */ - var asmBoxTo : Map[BType, MethodNameAndType] = _ - var asmUnboxTo: Map[BType, MethodNameAndType] = _ + lazy val asmBoxTo : Map[BType, MethodNameAndType] = Map( + BOOL -> MethodNameAndType("boxToBoolean", MethodBType(List(BOOL), BOXED_BOOLEAN)), + BYTE -> MethodNameAndType("boxToByte", MethodBType(List(BYTE), BOXED_BYTE)), + CHAR -> MethodNameAndType("boxToCharacter", MethodBType(List(CHAR), BOXED_CHAR)), + SHORT -> MethodNameAndType("boxToShort", MethodBType(List(SHORT), BOXED_SHORT)), + INT -> MethodNameAndType("boxToInteger", MethodBType(List(INT), BOXED_INT)), + LONG -> MethodNameAndType("boxToLong", MethodBType(List(LONG), BOXED_LONG)), + FLOAT -> MethodNameAndType("boxToFloat", MethodBType(List(FLOAT), BOXED_FLOAT)), + DOUBLE -> MethodNameAndType("boxToDouble", MethodBType(List(DOUBLE), BOXED_DOUBLE)) + ) + + lazy val asmUnboxTo: Map[BType, MethodNameAndType] = Map( + BOOL -> MethodNameAndType("unboxToBoolean", MethodBType(List(ObjectReference), BOOL)), + BYTE -> MethodNameAndType("unboxToByte", MethodBType(List(ObjectReference), BYTE)), + CHAR -> MethodNameAndType("unboxToChar", MethodBType(List(ObjectReference), CHAR)), + SHORT -> MethodNameAndType("unboxToShort", MethodBType(List(ObjectReference), SHORT)), + INT -> MethodNameAndType("unboxToInt", MethodBType(List(ObjectReference), INT)), + LONG -> MethodNameAndType("unboxToLong", MethodBType(List(ObjectReference), LONG)), + FLOAT -> MethodNameAndType("unboxToFloat", MethodBType(List(ObjectReference), FLOAT)), + DOUBLE -> MethodNameAndType("unboxToDouble", MethodBType(List(ObjectReference), DOUBLE)) + ) + + lazy val typeOfArrayOp: Map[Int, BType] = { + import scalaPrimitives._ + Map( + (List(ZARRAY_LENGTH, ZARRAY_GET, ZARRAY_SET) map (_ -> BOOL)) ++ + (List(BARRAY_LENGTH, BARRAY_GET, BARRAY_SET) map (_ -> BYTE)) ++ + (List(SARRAY_LENGTH, SARRAY_GET, SARRAY_SET) map (_ -> SHORT)) ++ + (List(CARRAY_LENGTH, CARRAY_GET, CARRAY_SET) map (_ -> CHAR)) ++ + (List(IARRAY_LENGTH, IARRAY_GET, IARRAY_SET) map (_ -> INT)) ++ + (List(LARRAY_LENGTH, LARRAY_GET, LARRAY_SET) map (_ -> LONG)) ++ + (List(FARRAY_LENGTH, FARRAY_GET, FARRAY_SET) map (_ -> FLOAT)) ++ + (List(DARRAY_LENGTH, DARRAY_GET, DARRAY_SET) map (_ -> DOUBLE)) ++ + (List(OARRAY_LENGTH, OARRAY_GET, OARRAY_SET) map (_ -> ObjectReference)) : _* + ) + } +} - var typeOfArrayOp: Map[Int, BType] = _ +/** + * This trait make some core BTypes availalbe that don't depend on a Global instance. Some core + * BTypes are required to be accessible in the BTypes trait, which does not have access to Global. + * + * BTypes cannot refer to CoreBTypesProxy because some of its members depend on global, for example + * the type Symbol in + * def primitiveTypeMap: Map[Symbol, PrimitiveBType] + */ +trait CoreBTypesProxyGlobalIndependent[BTS <: BTypes] { + val bTypes: BTS + import bTypes._ - /** - * Initialize core ClassBTypes computed from symbols. Invoked once for each compiler run. - */ - def intializeCoreBTypes(): Unit = { - primitiveTypeMap = Map( - UnitClass -> UNIT, - BooleanClass -> BOOL, - CharClass -> CHAR, - ByteClass -> BYTE, - ShortClass -> SHORT, - IntClass -> INT, - LongClass -> LONG, - FloatClass -> FLOAT, - DoubleClass -> DOUBLE - ) + def boxedClasses: Set[ClassBType] - BOXED_UNIT = classBTypeFromSymbol(requiredClass[java.lang.Void]) - BOXED_BOOLEAN = classBTypeFromSymbol(BoxedBooleanClass) - BOXED_BYTE = classBTypeFromSymbol(BoxedByteClass) - BOXED_SHORT = classBTypeFromSymbol(BoxedShortClass) - BOXED_CHAR = classBTypeFromSymbol(BoxedCharacterClass) - BOXED_INT = classBTypeFromSymbol(BoxedIntClass) - BOXED_LONG = classBTypeFromSymbol(BoxedLongClass) - BOXED_FLOAT = classBTypeFromSymbol(BoxedFloatClass) - BOXED_DOUBLE = classBTypeFromSymbol(BoxedDoubleClass) - - boxedClassOfPrimitive = Map( - UNIT -> BOXED_UNIT, - BOOL -> BOXED_BOOLEAN, - BYTE -> BOXED_BYTE, - SHORT -> BOXED_SHORT, - CHAR -> BOXED_CHAR, - INT -> BOXED_INT, - LONG -> BOXED_LONG, - FLOAT -> BOXED_FLOAT, - DOUBLE -> BOXED_DOUBLE - ) + def RT_NOTHING : ClassBType + def RT_NULL : ClassBType - boxedClasses = boxedClassOfPrimitive.values.toSet - - boxResultType = { - for ((valueClassSym, boxMethodSym) <- currentRun.runDefinitions.boxMethod) - yield boxMethodSym -> boxedClassOfPrimitive(primitiveTypeMap(valueClassSym)) - } - - unboxResultType = { - for ((valueClassSym, unboxMethodSym) <- currentRun.runDefinitions.unboxMethod) - yield unboxMethodSym -> primitiveTypeMap(valueClassSym) - } - - // TODO @lry Once there's a 2.11.2 starr, use the commented argument list. The current starr crashes on the type literal `scala.runtime.Nothing$` - RT_NOTHING = classBTypeFromSymbol(rootMirror.getRequiredClass("scala.runtime.Nothing$")) // (requiredClass[scala.runtime.Nothing$]) - RT_NULL = classBTypeFromSymbol(rootMirror.getRequiredClass("scala.runtime.Null$")) // (requiredClass[scala.runtime.Null$]) - - ObjectReference = classBTypeFromSymbol(ObjectClass) - objArrayReference = ArrayBType(ObjectReference) - - StringReference = classBTypeFromSymbol(StringClass) - StringBuilderReference = classBTypeFromSymbol(StringBuilderClass) - ThrowableReference = classBTypeFromSymbol(ThrowableClass) - jlCloneableReference = classBTypeFromSymbol(JavaCloneableClass) // java/lang/Cloneable - jlNPEReference = classBTypeFromSymbol(NullPointerExceptionClass) // java/lang/NullPointerException - jioSerializableReference = classBTypeFromSymbol(JavaSerializableClass) // java/io/Serializable - scalaSerializableReference = classBTypeFromSymbol(SerializableClass) // scala/Serializable - classCastExceptionReference = classBTypeFromSymbol(ClassCastExceptionClass) // java/lang/ClassCastException - - srBooleanRef = classBTypeFromSymbol(requiredClass[scala.runtime.BooleanRef]) - srByteRef = classBTypeFromSymbol(requiredClass[scala.runtime.ByteRef]) - srCharRef = classBTypeFromSymbol(requiredClass[scala.runtime.CharRef]) - srIntRef = classBTypeFromSymbol(requiredClass[scala.runtime.IntRef]) - srLongRef = classBTypeFromSymbol(requiredClass[scala.runtime.LongRef]) - srFloatRef = classBTypeFromSymbol(requiredClass[scala.runtime.FloatRef]) - srDoubleRef = classBTypeFromSymbol(requiredClass[scala.runtime.DoubleRef]) - - hashMethodSym = getMember(ScalaRunTimeModule, nme.hash_) - - // TODO @lry avoiding going through through missingHook for every line in the REPL: https://github.com/scala/scala/commit/8d962ed4ddd310cc784121c426a2e3f56a112540 - AndroidParcelableInterface = getClassIfDefined("android.os.Parcelable") - AndroidCreatorClass = getClassIfDefined("android.os.Parcelable$Creator") - - BeanInfoAttr = requiredClass[scala.beans.BeanInfo] - - String_valueOf = { - getMember(StringModule, nme.valueOf) filter (sym => sym.info.paramTypes match { - case List(pt) => pt.typeSymbol == ObjectClass - case _ => false - }) - } - - // scala.FunctionX and scala.runtim.AbstractFunctionX - FunctionReference = (0 to MaxFunctionArity).map(i => classBTypeFromSymbol(FunctionClass(i)))(collection.breakOut) - - AbstractFunctionReference = (0 to MaxFunctionArity).map(i => classBTypeFromSymbol(AbstractFunctionClass(i)))(collection.breakOut) - - AbstractFunctionArityMap = AbstractFunctionReference.zipWithIndex.toMap - - PartialFunctionReference = classBTypeFromSymbol(PartialFunctionClass) - AbstractPartialFunctionReference = classBTypeFromSymbol(AbstractPartialFunctionClass) - - BoxesRunTime = classBTypeFromSymbol(requiredClass[scala.runtime.BoxesRunTime]) - - asmBoxTo = Map( - BOOL -> MethodNameAndType("boxToBoolean", MethodBType(List(BOOL), BOXED_BOOLEAN)), - BYTE -> MethodNameAndType("boxToByte", MethodBType(List(BYTE), BOXED_BYTE)), - CHAR -> MethodNameAndType("boxToCharacter", MethodBType(List(CHAR), BOXED_CHAR)), - SHORT -> MethodNameAndType("boxToShort", MethodBType(List(SHORT), BOXED_SHORT)), - INT -> MethodNameAndType("boxToInteger", MethodBType(List(INT), BOXED_INT)), - LONG -> MethodNameAndType("boxToLong", MethodBType(List(LONG), BOXED_LONG)), - FLOAT -> MethodNameAndType("boxToFloat", MethodBType(List(FLOAT), BOXED_FLOAT)), - DOUBLE -> MethodNameAndType("boxToDouble", MethodBType(List(DOUBLE), BOXED_DOUBLE)) - ) + def ObjectReference : ClassBType + def jlCloneableReference : ClassBType + def jioSerializableReference : ClassBType +} - asmUnboxTo = Map( - BOOL -> MethodNameAndType("unboxToBoolean", MethodBType(List(ObjectReference), BOOL)), - BYTE -> MethodNameAndType("unboxToByte", MethodBType(List(ObjectReference), BYTE)), - CHAR -> MethodNameAndType("unboxToChar", MethodBType(List(ObjectReference), CHAR)), - SHORT -> MethodNameAndType("unboxToShort", MethodBType(List(ObjectReference), SHORT)), - INT -> MethodNameAndType("unboxToInt", MethodBType(List(ObjectReference), INT)), - LONG -> MethodNameAndType("unboxToLong", MethodBType(List(ObjectReference), LONG)), - FLOAT -> MethodNameAndType("unboxToFloat", MethodBType(List(ObjectReference), FLOAT)), - DOUBLE -> MethodNameAndType("unboxToDouble", MethodBType(List(ObjectReference), DOUBLE)) - ) +/** + * See comment in class [[CoreBTypes]]. + */ +final class CoreBTypesProxy[BTFS <: BTypesFromSymbols[_ <: Global]](val bTypes: BTFS) extends CoreBTypesProxyGlobalIndependent[BTFS] { + import bTypes._ + import global._ - typeOfArrayOp = { - import scalaPrimitives._ - Map( - (List(ZARRAY_LENGTH, ZARRAY_GET, ZARRAY_SET) map (_ -> BOOL)) ++ - (List(BARRAY_LENGTH, BARRAY_GET, BARRAY_SET) map (_ -> BYTE)) ++ - (List(SARRAY_LENGTH, SARRAY_GET, SARRAY_SET) map (_ -> SHORT)) ++ - (List(CARRAY_LENGTH, CARRAY_GET, CARRAY_SET) map (_ -> CHAR)) ++ - (List(IARRAY_LENGTH, IARRAY_GET, IARRAY_SET) map (_ -> INT)) ++ - (List(LARRAY_LENGTH, LARRAY_GET, LARRAY_SET) map (_ -> LONG)) ++ - (List(FARRAY_LENGTH, FARRAY_GET, FARRAY_SET) map (_ -> FLOAT)) ++ - (List(DARRAY_LENGTH, DARRAY_GET, DARRAY_SET) map (_ -> DOUBLE)) ++ - (List(OARRAY_LENGTH, OARRAY_GET, OARRAY_SET) map (_ -> ObjectReference)) : _* - ) - } + private[this] var _coreBTypes: CoreBTypes[bTypes.type] = _ + def setBTypes(coreBTypes: CoreBTypes[BTFS]): Unit = { + _coreBTypes = coreBTypes.asInstanceOf[CoreBTypes[bTypes.type]] } + + def primitiveTypeMap: Map[Symbol, PrimitiveBType] = _coreBTypes.primitiveTypeMap + + def BOXED_UNIT : ClassBType = _coreBTypes.BOXED_UNIT + def BOXED_BOOLEAN : ClassBType = _coreBTypes.BOXED_BOOLEAN + def BOXED_BYTE : ClassBType = _coreBTypes.BOXED_BYTE + def BOXED_SHORT : ClassBType = _coreBTypes.BOXED_SHORT + def BOXED_CHAR : ClassBType = _coreBTypes.BOXED_CHAR + def BOXED_INT : ClassBType = _coreBTypes.BOXED_INT + def BOXED_LONG : ClassBType = _coreBTypes.BOXED_LONG + def BOXED_FLOAT : ClassBType = _coreBTypes.BOXED_FLOAT + def BOXED_DOUBLE : ClassBType = _coreBTypes.BOXED_DOUBLE + + def boxedClasses: Set[ClassBType] = _coreBTypes.boxedClasses + + def boxedClassOfPrimitive: Map[PrimitiveBType, ClassBType] = _coreBTypes.boxedClassOfPrimitive + + def boxResultType: Map[Symbol, ClassBType] = _coreBTypes.boxResultType + + def unboxResultType: Map[Symbol, PrimitiveBType] = _coreBTypes.unboxResultType + + def RT_NOTHING : ClassBType = _coreBTypes.RT_NOTHING + def RT_NULL : ClassBType = _coreBTypes.RT_NULL + + def ObjectReference : ClassBType = _coreBTypes.ObjectReference + def objArrayReference : ArrayBType = _coreBTypes.objArrayReference + + def StringReference : ClassBType = _coreBTypes.StringReference + def StringBuilderReference : ClassBType = _coreBTypes.StringBuilderReference + def ThrowableReference : ClassBType = _coreBTypes.ThrowableReference + def jlCloneableReference : ClassBType = _coreBTypes.jlCloneableReference + def jlNPEReference : ClassBType = _coreBTypes.jlNPEReference + def jioSerializableReference : ClassBType = _coreBTypes.jioSerializableReference + def scalaSerializableReference : ClassBType = _coreBTypes.scalaSerializableReference + def classCastExceptionReference : ClassBType = _coreBTypes.classCastExceptionReference + + def srBooleanRef : ClassBType = _coreBTypes.srBooleanRef + def srByteRef : ClassBType = _coreBTypes.srByteRef + def srCharRef : ClassBType = _coreBTypes.srCharRef + def srIntRef : ClassBType = _coreBTypes.srIntRef + def srLongRef : ClassBType = _coreBTypes.srLongRef + def srFloatRef : ClassBType = _coreBTypes.srFloatRef + def srDoubleRef : ClassBType = _coreBTypes.srDoubleRef + + def hashMethodSym: Symbol = _coreBTypes.hashMethodSym + + def AndroidParcelableInterface : Symbol = _coreBTypes.AndroidParcelableInterface + def AndroidCreatorClass : Symbol = _coreBTypes.AndroidCreatorClass + + def BeanInfoAttr: Symbol = _coreBTypes.BeanInfoAttr + + def String_valueOf: Symbol = _coreBTypes.String_valueOf + + def FunctionReference : Vector[ClassBType] = _coreBTypes.FunctionReference + def AbstractFunctionReference : Vector[ClassBType] = _coreBTypes.AbstractFunctionReference + def AbstractFunctionArityMap : Map[ClassBType, Int] = _coreBTypes.AbstractFunctionArityMap + + def PartialFunctionReference : ClassBType = _coreBTypes.PartialFunctionReference + def AbstractPartialFunctionReference : ClassBType = _coreBTypes.AbstractPartialFunctionReference + + def BoxesRunTime: ClassBType = _coreBTypes.BoxesRunTime + + def asmBoxTo : Map[BType, MethodNameAndType] = _coreBTypes.asmBoxTo + def asmUnboxTo: Map[BType, MethodNameAndType] = _coreBTypes.asmUnboxTo + + def typeOfArrayOp: Map[Int, BType] = _coreBTypes.typeOfArrayOp } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala index 480767f40774..0a7c894a6911 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala @@ -47,6 +47,7 @@ abstract class GenBCode extends BCodeSyncAndTry { import global._ import bTypes._ + import coreBTypes._ val phaseName = "jvm" From 3bcad9abc0010931b230b182f6f5de7e0860ae45 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 14 Aug 2014 16:23:59 +0200 Subject: [PATCH 495/826] Fix indentation in delambdafy --- .../tools/nsc/transform/Delambdafy.scala | 50 +++++++++---------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala index 1f8ab7e88799..371061662e49 100644 --- a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala +++ b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala @@ -252,39 +252,39 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre captureProxies2 += ((capture, sym)) } - // the Optional proxy that will hold a reference to the 'this' - // object used by the lambda, if any. NoSymbol if there is no this proxy - val thisProxy = { - val target = targetMethod(originalFunction) - if (thisReferringMethods contains target) { - val sym = anonClass.newVariable(nme.FAKE_LOCAL_THIS, originalFunction.pos, SYNTHETIC) - sym.info = oldClass.tpe - sym - } else NoSymbol - } + // the Optional proxy that will hold a reference to the 'this' + // object used by the lambda, if any. NoSymbol if there is no this proxy + val thisProxy = { + val target = targetMethod(originalFunction) + if (thisReferringMethods contains target) { + val sym = anonClass.newVariable(nme.FAKE_LOCAL_THIS, originalFunction.pos, SYNTHETIC) + sym.info = oldClass.tpe + sym + } else NoSymbol + } - val decapturify = new DeCapturifyTransformer(captureProxies2, unit, oldClass, anonClass, originalFunction.symbol.pos, thisProxy) + val decapturify = new DeCapturifyTransformer(captureProxies2, unit, oldClass, anonClass, originalFunction.symbol.pos, thisProxy) - val accessorMethod = createAccessorMethod(thisProxy, originalFunction) + val accessorMethod = createAccessorMethod(thisProxy, originalFunction) - val decapturedFunction = decapturify.transform(originalFunction).asInstanceOf[Function] + val decapturedFunction = decapturify.transform(originalFunction).asInstanceOf[Function] - val members = (optionSymbol(thisProxy).toList ++ (captureProxies2 map (_._2))) map {member => - anonClass.info.decls enter member - ValDef(member, gen.mkZero(member.tpe)) setPos decapturedFunction.pos - } + val members = (optionSymbol(thisProxy).toList ++ (captureProxies2 map (_._2))) map {member => + anonClass.info.decls enter member + ValDef(member, gen.mkZero(member.tpe)) setPos decapturedFunction.pos + } - // constructor - val constr = createConstructor(anonClass, members) + // constructor + val constr = createConstructor(anonClass, members) - // apply method with same arguments and return type as original lambda. - val applyMethodDef = createApplyMethod(anonClass, decapturedFunction, accessorMethod, thisProxy) + // apply method with same arguments and return type as original lambda. + val applyMethodDef = createApplyMethod(anonClass, decapturedFunction, accessorMethod, thisProxy) - val bridgeMethod = createBridgeMethod(anonClass, originalFunction, applyMethodDef) + val bridgeMethod = createBridgeMethod(anonClass, originalFunction, applyMethodDef) - def fulldef(sym: Symbol) = - if (sym == NoSymbol) sym.toString - else s"$sym: ${sym.tpe} in ${sym.owner}" + def fulldef(sym: Symbol) = + if (sym == NoSymbol) sym.toString + else s"$sym: ${sym.tpe} in ${sym.owner}" bridgeMethod foreach (bm => // TODO SI-6260 maybe just create the apply method with the signature (Object => Object) in all cases From f324ca5e14d29f8b4f6f7bbacc1c17f4233cd260 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Wed, 20 Aug 2014 13:17:16 +0200 Subject: [PATCH 496/826] SI-8803 generate super accessor for super[A], if A is outer superclass class C extends A with T { class I { C.super[T] C.super[A] } } A super call in a nested class of the form super[T] where T is a parent trait of the outer class doesn't need an accessor: mixin can directly re-route the call to the correct implementation class - it's statically known to be T$class. However, if a nested class accesses super[A] and A is the superclass of the outer class (not a trait), then we need a super accessor in the outer class. We need to add the mixin name to the super accessor name, otherwise it clashes with non-qualified super accessors. --- .../nsc/typechecker/SuperAccessors.scala | 20 +++++-- .../scala/reflect/internal/StdNames.scala | 2 +- test/files/run/t8803.check | 16 ++++++ test/files/run/t8803.scala | 57 +++++++++++++++++++ 4 files changed, 90 insertions(+), 5 deletions(-) create mode 100644 test/files/run/t8803.check create mode 100644 test/files/run/t8803.scala diff --git a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala index 38b00a015bac..db81eecdf5fc 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SuperAccessors.scala @@ -82,11 +82,11 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT val buf = accDefs.getOrElse(clazz, sys.error("no acc def buf for "+clazz)) buf += typers(clazz) typed tree } - private def ensureAccessor(sel: Select) = { + private def ensureAccessor(sel: Select, mixName: TermName = nme.EMPTY) = { val Select(qual, name) = sel val sym = sel.symbol val clazz = qual.symbol - val supername = nme.superName(name) + val supername = nme.superName(name, mixName) val superAcc = clazz.info.decl(supername).suchThat(_.alias == sym) orElse { debuglog(s"add super acc ${sym.fullLocationString} to $clazz") val acc = clazz.newMethod(supername, sel.pos, SUPERACCESSOR | PRIVATE | ARTIFACT) setAlias sym @@ -150,8 +150,20 @@ abstract class SuperAccessors extends transform.Transform with transform.TypingT } } - if (name.isTermName && mix == tpnme.EMPTY && (clazz.isTrait || clazz != currentClass || !validCurrentOwner)) - ensureAccessor(sel) + def mixIsTrait = sup.tpe match { + case SuperType(thisTpe, superTpe) => superTpe.typeSymbol.isTrait + } + + val needAccessor = name.isTermName && { + mix.isEmpty && (clazz.isTrait || clazz != currentClass || !validCurrentOwner) || + // SI-8803. If we access super[A] from an inner class (!= currentClass) or closure (validCurrentOwner), + // where A is the superclass we need an accessor. If A is a parent trait we don't: in this case mixin + // will re-route the super call directly to the impl class (it's statically known). + !mix.isEmpty && (clazz != currentClass || !validCurrentOwner) && !mixIsTrait + } + + if (needAccessor) + ensureAccessor(sel, mix.toTermName) else sel } diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala index 6848c357c5eb..d203218c0978 100644 --- a/src/reflect/scala/reflect/internal/StdNames.scala +++ b/src/reflect/scala/reflect/internal/StdNames.scala @@ -473,7 +473,7 @@ trait StdNames { ) def localDummyName(clazz: Symbol): TermName = newTermName(LOCALDUMMY_PREFIX + clazz.name + ">") - def superName(name: Name): TermName = newTermName(SUPER_PREFIX_STRING + name) + def superName(name: Name, mix: Name = EMPTY): TermName = newTermName(SUPER_PREFIX_STRING + name + (if (mix.isEmpty) "" else "$" + mix)) /** The name of an accessor for protected symbols. */ def protName(name: Name): TermName = newTermName(PROTECTED_PREFIX + name) diff --git a/test/files/run/t8803.check b/test/files/run/t8803.check new file mode 100644 index 000000000000..bd26a0fb14aa --- /dev/null +++ b/test/files/run/t8803.check @@ -0,0 +1,16 @@ +a +b +b +c +a +b +b +c +a +b +b +c +a +b +b +c diff --git a/test/files/run/t8803.scala b/test/files/run/t8803.scala new file mode 100644 index 000000000000..2e56180502b6 --- /dev/null +++ b/test/files/run/t8803.scala @@ -0,0 +1,57 @@ +class A { + def m = "a" + protected def n = "a" +} + +trait B { + def m = "b" + protected def n = "b" +} + +class C extends A with B { + override def m = "c" + override protected def n = "c" + + val f1 = () => super[A].m + val f2 = () => super[B].m + val f3 = () => super.m + val f4 = () => this.m + + val g1 = new runtime.AbstractFunction0[String] { def apply() = C.super[A].m } + val g2 = new runtime.AbstractFunction0[String] { def apply() = C.super[B].m } + val g3 = new runtime.AbstractFunction0[String] { def apply() = C.super.m } + val g4 = new runtime.AbstractFunction0[String] { def apply() = C.this.m } + + val h1 = () => super[A].n + val h2 = () => super[B].n + val h3 = () => super.n + val h4 = () => this.n + + val i1 = new runtime.AbstractFunction0[String] { def apply() = C.super[A].n } + val i2 = new runtime.AbstractFunction0[String] { def apply() = C.super[B].n } + val i3 = new runtime.AbstractFunction0[String] { def apply() = C.super.n } + val i4 = new runtime.AbstractFunction0[String] { def apply() = C.this.n } +} + +object Test extends App { + val c = new C + println(c.f1()) + println(c.f2()) + println(c.f3()) + println(c.f4()) + + println(c.g1()) + println(c.g2()) + println(c.g3()) + println(c.g4()) + + println(c.h1()) + println(c.h2()) + println(c.h3()) + println(c.h4()) + + println(c.i1()) + println(c.i2()) + println(c.i3()) + println(c.i4()) +} From 984025b2bd15b343181aea9c00a50ac1cd721ca1 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Tue, 19 Aug 2014 15:54:01 +0200 Subject: [PATCH 497/826] SI-8498 @compileTimeOnly should be aware of bridge methods. Calling a @compileTimeOnly method from another @compileTimeOnly method happens when the former gets a bridge method. It should not throw an error. Calling the bridge or the method will anyway. --- src/compiler/scala/tools/nsc/typechecker/RefChecks.scala | 3 ++- test/files/neg/compile-time-only-a.check | 5 +---- test/files/pos/t8498.scala | 6 ++++++ 3 files changed, 9 insertions(+), 5 deletions(-) create mode 100644 test/files/pos/t8498.scala diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index 47465875e933..e16c906e3401 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -1287,6 +1287,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans private def checkUndesiredProperties(sym: Symbol, pos: Position) { // If symbol is deprecated, and the point of reference is not enclosed // in either a deprecated member or a scala bridge method, issue a warning. + // TODO: x.hasBridgeAnnotation doesn't seem to be needed here... if (sym.isDeprecated && !currentOwner.ownerChain.exists(x => x.isDeprecated || x.hasBridgeAnnotation)) currentRun.reporting.deprecationWarning(pos, sym) @@ -1305,7 +1306,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans reporter.warning(pos, s"${sym.fullLocationString} has changed semantics in version ${sym.migrationVersion.get}:\n${sym.migrationMessage.get}") } // See an explanation of compileTimeOnly in its scaladoc at scala.annotation.compileTimeOnly. - if (sym.isCompileTimeOnly) { + if (sym.isCompileTimeOnly && !currentOwner.ownerChain.exists(x => x.isCompileTimeOnly)) { def defaultMsg = sm"""Reference to ${sym.fullLocationString} should not have survived past type checking, |it should have been processed and eliminated during expansion of an enclosing macro.""" diff --git a/test/files/neg/compile-time-only-a.check b/test/files/neg/compile-time-only-a.check index 9bc96f6b9b2e..b1ed1d24c239 100644 --- a/test/files/neg/compile-time-only-a.check +++ b/test/files/neg/compile-time-only-a.check @@ -4,9 +4,6 @@ compile-time-only-a.scala:10: error: C3 compile-time-only-a.scala:12: error: C4 @compileTimeOnly("C4") case class C4(x: Int) ^ -compile-time-only-a.scala:17: error: C5 - implicit class C5(val x: Int) { - ^ compile-time-only-a.scala:32: error: C1 new C1() ^ @@ -76,4 +73,4 @@ compile-time-only-a.scala:75: error: placebo compile-time-only-a.scala:75: error: placebo @placebo def x = (2: @placebo) ^ -26 errors found +25 errors found diff --git a/test/files/pos/t8498.scala b/test/files/pos/t8498.scala new file mode 100644 index 000000000000..6808c89051a5 --- /dev/null +++ b/test/files/pos/t8498.scala @@ -0,0 +1,6 @@ +import scala.annotation.compileTimeOnly + +class C(val s: String) extends AnyVal { + @compileTimeOnly("error") + def error = ??? +} From 3d64deeb687452cb7e8e53b5a172e7bc7c50bf1b Mon Sep 17 00:00:00 2001 From: Rex Kerr Date: Thu, 29 May 2014 08:04:14 -0700 Subject: [PATCH 498/826] SI-8474 Inconsistent behavior of patch method Changed Iterator to be consistent with other collections. Also fixed SeqViewLike to validate/constrain inputs. No specific tests; quasi-comprehensive collection tests will cover this later. --- src/library/scala/collection/Iterator.scala | 40 ++++++++++++++----- .../scala/collection/SeqViewLike.scala | 23 ++++++++--- 2 files changed, 47 insertions(+), 16 deletions(-) diff --git a/src/library/scala/collection/Iterator.scala b/src/library/scala/collection/Iterator.scala index f6f46e158f98..660cc5a42a27 100644 --- a/src/library/scala/collection/Iterator.scala +++ b/src/library/scala/collection/Iterator.scala @@ -1088,6 +1088,9 @@ trait Iterator[+A] extends TraversableOnce[A] { } /** Returns this iterator with patched values. + * Patching at negative indices is the same as patching starting at 0. + * Patching at indices at or larger than the length of the original iterator appends the patch to the end. + * If more values are replaced than actually exist, the excess is ignored. * * @param from The start index from which to patch * @param patchElems The iterator of patch values @@ -1096,18 +1099,33 @@ trait Iterator[+A] extends TraversableOnce[A] { */ def patch[B >: A](from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B] = new AbstractIterator[B] { private var origElems = self - private var i = 0 - def hasNext: Boolean = - if (i < from) origElems.hasNext - else patchElems.hasNext || origElems.hasNext + private var i = (if (from > 0) from else 0) // Counts down, switch to patch on 0, -1 means use patch first + def hasNext: Boolean = { + if (i == 0) { + origElems = origElems drop replaced + i = -1 + } + origElems.hasNext || patchElems.hasNext + } def next(): B = { - // We have to do this *first* just in case from = 0. - if (i == from) origElems = origElems drop replaced - val result: B = - if (i < from || !patchElems.hasNext) origElems.next() - else patchElems.next() - i += 1 - result + if (i == 0) { + origElems = origElems drop replaced + i = -1 + } + if (i < 0) { + if (patchElems.hasNext) patchElems.next() + else origElems.next() + } + else { + if (origElems.hasNext) { + i -= 1 + origElems.next() + } + else { + i = -1 + patchElems.next() + } + } } } diff --git a/src/library/scala/collection/SeqViewLike.scala b/src/library/scala/collection/SeqViewLike.scala index 5e31ac4a5301..e719f19c78b7 100644 --- a/src/library/scala/collection/SeqViewLike.scala +++ b/src/library/scala/collection/SeqViewLike.scala @@ -154,17 +154,27 @@ trait SeqViewLike[+A, } } + // Note--for this to work, must ensure 0 <= from and 0 <= replaced + // Must also take care to allow patching inside an infinite stream + // (patching in an infinite stream is not okay) trait Patched[B >: A] extends Transformed[B] { protected[this] val from: Int protected[this] val patch: GenSeq[B] protected[this] val replaced: Int private lazy val plen = patch.length override def iterator: Iterator[B] = self.iterator patch (from, patch.iterator, replaced) - def length: Int = self.length + plen - replaced - def apply(idx: Int): B = - if (idx < from) self.apply(idx) - else if (idx < from + plen) patch.apply(idx - from) + def length: Int = { + val len = self.length + val pre = math.min(from, len) + val post = math.max(0, len - pre - replaced) + pre + plen + post + } + def apply(idx: Int): B = { + val actualFrom = if (self.lengthCompare(from) < 0) self.length else from + if (idx < actualFrom) self.apply(idx) + else if (idx < actualFrom + plen) patch.apply(idx - actualFrom) else self.apply(idx - plen + replaced) + } final override protected[this] def viewIdentifier = "P" } @@ -210,7 +220,10 @@ trait SeqViewLike[+A, override def reverse: This = newReversed.asInstanceOf[This] override def patch[B >: A, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[This, B, That]): That = { - newPatched(from, patch, replaced).asInstanceOf[That] + // Be careful to not evaluate the entire sequence! Patch should work (slowly, perhaps) on infinite streams. + val nonNegFrom = math.max(0,from) + val nonNegRep = math.max(0,replaced) + newPatched(nonNegFrom, patch, nonNegRep).asInstanceOf[That] // was: val b = bf(repr) // if (b.isInstanceOf[NoBuilder[_]]) newPatched(from, patch, replaced).asInstanceOf[That] // else super.patch[B, That](from, patch, replaced)(bf) From 42f8a96a37cdeb869382b0a1bb084296299302c4 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Fri, 22 Aug 2014 14:49:18 +0200 Subject: [PATCH 499/826] Add support for running a specific Junit test/method. Unless I really missed something, there is currently no way to run a specific Junit test (class or method). Running the whole thing is going to get worse and worse since Junit is supposed to be the preferred way, so here it goes: // will run all methods in a test file ant test.junit -Dtest.class=scala.WhateverTest // will run a specific method (just an alias for the one below) ant test.junit -Dtest.class=scala.WhateverTest -Dtest.method=mymethod // will run several methods (comma separated) ant test.junit -Dtest.class=scala.WhateverTest -Dtest.methods="foo,bar" `test.method(s)` without `test.class` is just ignored (all tests are run). --- build.xml | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/build.xml b/build.xml index b7950f971ce5..6c750e530df5 100755 --- a/build.xml +++ b/build.xml @@ -1440,9 +1440,13 @@ TODO: + + - + + + From 6f54b1dfede5d9b375eab029ef682e1a61da9a70 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Thu, 21 Aug 2014 11:17:46 +0200 Subject: [PATCH 500/826] SI-1264 fsc compiler output should go to stderr, like scalac This properly sends the compiler output of `scala -e`, scala worksheets, ... to sdterr, just like scalac does. Before: $ scala -e 'foo' > /dev/null $ After: $ scala -e 'foo' > /dev/null /tmp/scalacmd8514641341855028538.scala:1: error: not found: value foo foo ^ one error found $ --- src/compiler/scala/tools/nsc/CompileSocket.scala | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/compiler/scala/tools/nsc/CompileSocket.scala b/src/compiler/scala/tools/nsc/CompileSocket.scala index c4f06b59ec53..c693fbe8e29d 100644 --- a/src/compiler/scala/tools/nsc/CompileSocket.scala +++ b/src/compiler/scala/tools/nsc/CompileSocket.scala @@ -32,7 +32,8 @@ trait HasCompileSocket { if (isErrorMessage(line)) noErrors = false - compileSocket.echo(line) + // be consistent with scalac: everything goes to stderr + compileSocket.warn(line) loop() } try loop() From 066d1026d9b5783d3358bc4389b2371cee00ed8c Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Thu, 21 Aug 2014 11:36:44 +0200 Subject: [PATCH 501/826] SI-5227 make fsc notify its client upon compiler crash Fsc shoudln't just write to its own stderr when a major compiler crash happens, it should also send an error to the client (`scala -e` for example). Otherwise the client thinks everything went fine (silence == success) and tries to run something, crashes too, and displays only its own error, not the original one. --- src/compiler/scala/tools/nsc/CompileServer.scala | 1 + 1 file changed, 1 insertion(+) diff --git a/src/compiler/scala/tools/nsc/CompileServer.scala b/src/compiler/scala/tools/nsc/CompileServer.scala index 1f3a4237eb3d..029e1c46297b 100644 --- a/src/compiler/scala/tools/nsc/CompileServer.scala +++ b/src/compiler/scala/tools/nsc/CompileServer.scala @@ -152,6 +152,7 @@ class StandardCompileServer extends SocketServer { clearCompiler() case ex: Throwable => warn("Compile server encountered fatal condition: " + ex) + reporter.error(null, "Compile server encountered fatal condition: " + ex.getMessage) shutdown = true throw ex } From a1b18d8112af2da7624d6cae234c33cdfdbd3287 Mon Sep 17 00:00:00 2001 From: rubyu Date: Tue, 26 Aug 2014 19:42:01 +0900 Subject: [PATCH 502/826] Translate to jUnit test cases --- test/files/run/t7350.check | 43 ---- test/files/run/t7350.scala | 302 ----------------------- test/junit/scala/sys/process/t7350.scala | 298 ++++++++++++++++++++++ 3 files changed, 298 insertions(+), 345 deletions(-) delete mode 100644 test/files/run/t7350.check delete mode 100644 test/files/run/t7350.scala create mode 100644 test/junit/scala/sys/process/t7350.scala diff --git a/test/files/run/t7350.check b/test/files/run/t7350.check deleted file mode 100644 index 5959e0440083..000000000000 --- a/test/files/run/t7350.check +++ /dev/null @@ -1,43 +0,0 @@ -PipedProcesses need not to release resources when it normally ends -- source.releaseCount: 0 -- sink.releaseCount: 0 -- a.destroyCount: 0 -- b.destroyCount: 0 -PipedProcesses must release resources when b.run() fails -- source.releaseCount: 1 -- sink.releaseCount: 1 -- a.destroyCount: 0 -- b.destroyCount: 0 -PipedProcesses must release resources when a.run() fails -- source.releaseCount: 1 -- sink.releaseCount: 1 -- a.destroyCount: 0 -- b.destroyCount: 1 -PipedProcesses must release resources when interrupted waiting for first.exitValue() -- source.releaseCount: 1 -- sink.releaseCount: 1 -- a.destroyCount: 1 -- b.destroyCount: 1 -PipedProcesses must release resources when interrupted waiting for second.exitValue() -- source.releaseCount: 1 -- sink.releaseCount: 1 -- a.destroyCount: 1 -- b.destroyCount: 1 -PipeSource and PipeSink must release resources when it normally ends -- in.closed: true -- out.closed: true -- source.isReleased: true -- sink.isReleased: true -PipeSource and PipeSink must release resources when when waiting for source.take() -- out.closed: true -- source.isReleased: true -- sink.isReleased: true -PipeSource and PipeSink must release resources when when waiting for sink.take() -- in.closed: true -- source.isReleased: true -- sink.isReleased: true -PipeSource and PipeSink must release resources when copying stream -- in.closed: true -- out.closed: true -- source.isReleased: true -- sink.isReleased: true diff --git a/test/files/run/t7350.scala b/test/files/run/t7350.scala deleted file mode 100644 index 156d2f0719cf..000000000000 --- a/test/files/run/t7350.scala +++ /dev/null @@ -1,302 +0,0 @@ - -import scala.sys.process.debug._ -import scala.sys.process.{ProcessLogger, BasicIO} -import java.io.{Closeable, ByteArrayInputStream, ByteArrayOutputStream, InputStream, IOException} -import scala.concurrent.{Future, Await} -import scala.concurrent.duration.{Duration, SECONDS} -import scala.util.control.Exception._ -import scala.concurrent.ExecutionContext.Implicits.global - -object Test extends App { - // Each test normally ends in a moment, but for a worst case, - // waits until 5 seconds and breaks off. - - // Tests for PipedProcesses - - println("PipedProcesses need not to release resources when it normally ends") - - { - val io = BasicIO(false, ProcessLogger(_ => ())) - val source = new PipeSourceMock - val sink = new PipeSinkMock - val a = new ProcessMock(error = false) - val b = new ProcessMock(error = false) - val p = new PipedProcesses(new ProcessBuilderMock(a, error = false), new ProcessBuilderMock(b, error = false), io, false) - val f = Future { - p.callRunAndExitValue(source, sink) - } - Await.result(f, Duration(5, SECONDS)) - println(s"- source.releaseCount: ${source.releaseCount}") - println(s"- sink.releaseCount: ${sink.releaseCount}") - println(s"- a.destroyCount: ${a.destroyCount}") - println(s"- b.destroyCount: ${b.destroyCount}") - } - - println("PipedProcesses must release resources when b.run() fails") - - { - val io = BasicIO(false, ProcessLogger(_ => ())) - val source = new PipeSourceMock - val sink = new PipeSinkMock - val a = new ProcessMock(error = false) - val b = new ProcessMock(error = false) - val p = new PipedProcesses(new ProcessBuilderMock(a, error = false), new ProcessBuilderMock(b, error = true), io, false) - val f = Future { - ignoring(classOf[IOException]) { - p.callRunAndExitValue(source, sink) - } - } - Await.result(f, Duration(5, SECONDS)) - println(s"- source.releaseCount: ${source.releaseCount}") - println(s"- sink.releaseCount: ${sink.releaseCount}") - println(s"- a.destroyCount: ${a.destroyCount}") - println(s"- b.destroyCount: ${b.destroyCount}") - } - - println("PipedProcesses must release resources when a.run() fails") - - { - val io = BasicIO(false, ProcessLogger(_ => ())) - val source = new PipeSourceMock - val sink = new PipeSinkMock - val a = new ProcessMock(error = false) - val b = new ProcessMock(error = false) - val p = new PipedProcesses(new ProcessBuilderMock(a, error = true), new ProcessBuilderMock(b, error = false), io, false) - val f = Future { - ignoring(classOf[IOException]) { - p.callRunAndExitValue(source, sink) - } - } - Await.result(f, Duration(5, SECONDS)) - println(s"- source.releaseCount: ${source.releaseCount}") - println(s"- sink.releaseCount: ${sink.releaseCount}") - println(s"- a.destroyCount: ${a.destroyCount}") - println(s"- b.destroyCount: ${b.destroyCount}") - } - - println("PipedProcesses must release resources when interrupted waiting for first.exitValue()") - - { - val io = BasicIO(false, ProcessLogger(_ => ())) - val source = new PipeSourceMock - val sink = new PipeSinkMock - val a = new ProcessMock(error = true) - val b = new ProcessMock(error = false) - val p = new PipedProcesses(new ProcessBuilderMock(a, error = false), new ProcessBuilderMock(b, error = false), io, false) - val f = Future { - p.callRunAndExitValue(source, sink) - } - Await.result(f, Duration(5, SECONDS)) - println(s"- source.releaseCount: ${source.releaseCount}") - println(s"- sink.releaseCount: ${sink.releaseCount}") - println(s"- a.destroyCount: ${a.destroyCount}") - println(s"- b.destroyCount: ${b.destroyCount}") - } - - println("PipedProcesses must release resources when interrupted waiting for second.exitValue()") - - { - val io = BasicIO(false, ProcessLogger(_ => ())) - val source = new PipeSourceMock - val sink = new PipeSinkMock - val a = new ProcessMock(error = false) - val b = new ProcessMock(error = true) - val p = new PipedProcesses(new ProcessBuilderMock(a, error = false), new ProcessBuilderMock(b, error = false), io, false) - val f = Future { - p.callRunAndExitValue(source, sink) - } - Await.result(f, Duration(5, SECONDS)) - println(s"- source.releaseCount: ${source.releaseCount}") - println(s"- sink.releaseCount: ${sink.releaseCount}") - println(s"- a.destroyCount: ${a.destroyCount}") - println(s"- b.destroyCount: ${b.destroyCount}") - } - - // Tests for PipeSource and PipeSink - - trait CloseChecking extends Closeable { - var closed = false - override def close() = closed = true - } - class DebugOutputStream extends ByteArrayOutputStream with CloseChecking - class DebugInputStream(s: String) extends ByteArrayInputStream(s.getBytes()) with CloseChecking - class DebugInfinityInputStream extends InputStream with CloseChecking { - def read() = 1 - } - - def sourceSink() = { - val source = new PipeSource - val sink = new PipeSink - source connectOut sink - source.start() - sink.start() - (source, sink) - } - - println("PipeSource and PipeSink must release resources when it normally ends") - - { - val in = new DebugInputStream("aaa") - val (source, sink) = sourceSink() - val out = new DebugOutputStream - source connectIn in - sink connectOut out - val f = Future { - source.join() - sink.join() - } - Await.result(f, Duration(5, SECONDS)) - println(s"- in.closed: ${in.closed}") - println(s"- out.closed: ${out.closed}") - println(s"- source.isReleased: ${source.isReleased}") - println(s"- sink.isReleased: ${sink.isReleased}") - } - - println("PipeSource and PipeSink must release resources when when waiting for source.take()") - - { - val (source, sink) = sourceSink() - val out = new DebugOutputStream - sink connectOut out - val f = Future { - sink.ensureRunloopStarted() - source.release() - sink.release() - } - Await.result(f, Duration(5, SECONDS)) - println(s"- out.closed: ${out.closed}") - println(s"- source.isReleased: ${source.isReleased}") - println(s"- sink.isReleased: ${sink.isReleased}") - } - - println("PipeSource and PipeSink must release resources when when waiting for sink.take()") - - { - val in = new DebugInputStream("aaa") - val (source, sink) = sourceSink() - source connectIn in - val f = Future { - source.ensureRunloopStarted() - source.release() - sink.release() - } - Await.result(f, Duration(5, SECONDS)) - println(s"- in.closed: ${in.closed}") - println(s"- source.isReleased: ${source.isReleased}") - println(s"- sink.isReleased: ${sink.isReleased}") - } - - println("PipeSource and PipeSink must release resources when copying stream") - - { - val in = new DebugInfinityInputStream - val (source, sink) = sourceSink() - val out = new DebugOutputStream - source connectIn in - sink connectOut out - val f = Future { - source.ensureRunloopStarted() - sink.ensureRunloopStarted() - source.release() - sink.release() - } - Await.result(f, Duration(5, SECONDS)) - println(s"- in.closed: ${in.closed}") - println(s"- out.closed: ${out.closed}") - println(s"- source.isReleased: ${source.isReleased}") - println(s"- sink.isReleased: ${sink.isReleased}") - } -} - -package scala.sys.process { - import java.io._ - import java.lang.reflect.InvocationTargetException - - object debug { - - class ProcessMock(error: Boolean) extends Process { - var destroyCount = 0 - def exitValue(): Int = { - if (error) { - throw new InterruptedException() - } - 0 - } - def destroy(): Unit = { destroyCount += 1 } - } - - class ProcessBuilderMock(process: Process, error: Boolean) extends ProcessBuilder.AbstractBuilder { - override def run(io: ProcessIO): Process = { - if (error) { - throw new IOException() - } - process - } - } - - class PipeSinkMock extends Process.PipeSink("PipeSinkMock") { - var releaseCount = 0 - override val pipe = null - override val sink = null - override def run(): Unit = {} - override def connectOut(out: OutputStream): Unit = {} - override def connectIn(pipeOut: PipedOutputStream): Unit = {} - override def release(): Unit = { releaseCount += 1 } - } - - class PipeSourceMock extends Process.PipeSource("PipeSourceMock") { - var releaseCount = 0 - override val pipe = null - override val source = null - override def run(): Unit = {} - override def connectIn(in: InputStream): Unit = {} - override def connectOut(sink: Process.PipeSink): Unit = {} - override def release(): Unit = { releaseCount += 1 } - } - - class PipedProcesses(a: ProcessBuilder, b: ProcessBuilder, defaultIO: ProcessIO, toError: Boolean) - extends Process.PipedProcesses(a, b, defaultIO, toError) { - def callRunAndExitValue(source: Process.PipeSource, sink: Process.PipeSink) = { - val m = classOf[Process.PipedProcesses].getDeclaredMethod("runAndExitValue", classOf[Process.PipeSource], classOf[Process.PipeSink]) - m.setAccessible(true) - try m.invoke(this, source, sink).asInstanceOf[Option[Int]] - catch { - case err: InvocationTargetException => throw err.getTargetException - } - } - } - - def throwsIOException(f: => Unit) = { - try { f; false } - catch { case _: IOException => true } - } - - class PipeSink extends Process.PipeSink("TestPipeSink") { - def ensureRunloopStarted() = { - while (sink.size() > 0) { - Thread.sleep(1) - } - } - def isReleased = { - val field = classOf[Process.PipeSink].getDeclaredField("pipe") - field.setAccessible(true) - val pipe = field.get(this).asInstanceOf[PipedInputStream] - !this.isAlive && throwsIOException { pipe.read() } - } - } - - class PipeSource extends Process.PipeSource("TestPipeSource") { - def ensureRunloopStarted() = { - while (source.size() > 0) { - Thread.sleep(1) - } - } - def isReleased = { - val field = classOf[Process.PipeSource].getDeclaredField("pipe") - field.setAccessible(true) - val pipe = field.get(this).asInstanceOf[PipedOutputStream] - !this.isAlive && throwsIOException { pipe.write(1) } - } - } - } -} \ No newline at end of file diff --git a/test/junit/scala/sys/process/t7350.scala b/test/junit/scala/sys/process/t7350.scala new file mode 100644 index 000000000000..7f3e8897f2f2 --- /dev/null +++ b/test/junit/scala/sys/process/t7350.scala @@ -0,0 +1,298 @@ + +package scala.sys.process + +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 +import org.junit.Test +import java.io.{InputStream, OutputStream, PipedInputStream, PipedOutputStream, ByteArrayInputStream, + ByteArrayOutputStream, IOException, Closeable} +import java.lang.reflect.InvocationTargetException +import scala.concurrent.{Await, Future} +import scala.concurrent.duration.{Duration, SECONDS} +import scala.concurrent.ExecutionContext.Implicits.global +import scala.util.control.Exception.ignoring + +// Each test normally ends in a moment, but for failure cases, waits until one second. + +@RunWith(classOf[JUnit4]) +class PipedProcessTest { + class ProcessMock(error: Boolean) extends Process { + var destroyCount = 0 + def exitValue(): Int = { + if (error) { + throw new InterruptedException() + } + 0 + } + def destroy(): Unit = { destroyCount += 1 } + } + + class ProcessBuilderMock(process: Process, error: Boolean) extends ProcessBuilder.AbstractBuilder { + override def run(io: ProcessIO): Process = { + if (error) { + throw new IOException() + } + process + } + } + + class PipeSinkMock extends Process.PipeSink("PipeSinkMock") { + var releaseCount = 0 + override val pipe = null + override val sink = null + override def run(): Unit = {} + override def connectOut(out: OutputStream): Unit = {} + override def connectIn(pipeOut: PipedOutputStream): Unit = {} + override def release(): Unit = { releaseCount += 1 } + } + + class PipeSourceMock extends Process.PipeSource("PipeSourceMock") { + var releaseCount = 0 + override val pipe = null + override val source = null + override def run(): Unit = {} + override def connectIn(in: InputStream): Unit = {} + override def connectOut(sink: Process.PipeSink): Unit = {} + override def release(): Unit = { releaseCount += 1 } + } + + class PipedProcesses(a: ProcessBuilder, b: ProcessBuilder, defaultIO: ProcessIO, toError: Boolean) + extends Process.PipedProcesses(a, b, defaultIO, toError) { + def callRunAndExitValue(source: Process.PipeSource, sink: Process.PipeSink) = { + val m = classOf[Process.PipedProcesses].getDeclaredMethod("runAndExitValue", classOf[Process.PipeSource], classOf[Process.PipeSink]) + m.setAccessible(true) + try m.invoke(this, source, sink).asInstanceOf[Option[Int]] + catch { + case err: InvocationTargetException => throw err.getTargetException + } + } + } + + // PipedProcesses need not to release resources when it normally end + @Test + def normallyEnd() { + val io = BasicIO(false, ProcessLogger(_ => ())) + val source = new PipeSourceMock + val sink = new PipeSinkMock + val a = new ProcessMock(error = false) + val b = new ProcessMock(error = false) + val p = new PipedProcesses(new ProcessBuilderMock(a, error = false), new ProcessBuilderMock(b, error = false), io, false) + val f = Future { + p.callRunAndExitValue(source, sink) + } + Await.result(f, Duration(1, SECONDS)) + assert(source.releaseCount == 0) + assert(sink.releaseCount == 0) + assert(a.destroyCount == 0) + assert(b.destroyCount == 0) + } + + // PipedProcesses must release resources when b.run() failed + @Test + def bFailed() { + val io = BasicIO(false, ProcessLogger(_ => ())) + val source = new PipeSourceMock + val sink = new PipeSinkMock + val a = new ProcessMock(error = false) + val b = new ProcessMock(error = false) + val p = new PipedProcesses(new ProcessBuilderMock(a, error = false), new ProcessBuilderMock(b, error = true), io, false) + val f = Future { + ignoring(classOf[IOException]) { + p.callRunAndExitValue(source, sink) + } + } + Await.result(f, Duration(1, SECONDS)) + assert(source.releaseCount == 1) + assert(sink.releaseCount == 1) + assert(a.destroyCount == 0) + assert(b.destroyCount == 0) + } + + // PipedProcesses must release resources when a.run() failed + @Test + def aFailed() { + val io = BasicIO(false, ProcessLogger(_ => ())) + val source = new PipeSourceMock + val sink = new PipeSinkMock + val a = new ProcessMock(error = false) + val b = new ProcessMock(error = false) + val p = new PipedProcesses(new ProcessBuilderMock(a, error = true), new ProcessBuilderMock(b, error = false), io, false) + val f = Future { + ignoring(classOf[IOException]) { + p.callRunAndExitValue(source, sink) + } + } + Await.result(f, Duration(1, SECONDS)) + assert(source.releaseCount == 1) + assert(sink.releaseCount == 1) + assert(a.destroyCount == 0) + assert(b.destroyCount == 1) + } + + // PipedProcesses must release resources when interrupted during waiting for first.exitValue() + @Test + def firstInterrupted() { + val io = BasicIO(false, ProcessLogger(_ => ())) + val source = new PipeSourceMock + val sink = new PipeSinkMock + val a = new ProcessMock(error = true) + val b = new ProcessMock(error = false) + val p = new PipedProcesses(new ProcessBuilderMock(a, error = false), new ProcessBuilderMock(b, error = false), io, false) + val f = Future { + p.callRunAndExitValue(source, sink) + } + Await.result(f, Duration(1, SECONDS)) + assert(source.releaseCount == 1) + assert(sink.releaseCount == 1) + assert(a.destroyCount == 1) + assert(b.destroyCount == 1) + } + + // PipedProcesses must release resources when interrupted during waiting for second.exitValue() + @Test + def secondInterrupted() { + val io = BasicIO(false, ProcessLogger(_ => ())) + val source = new PipeSourceMock + val sink = new PipeSinkMock + val a = new ProcessMock(error = false) + val b = new ProcessMock(error = true) + val p = new PipedProcesses(new ProcessBuilderMock(a, error = false), new ProcessBuilderMock(b, error = false), io, false) + val f = Future { + p.callRunAndExitValue(source, sink) + } + Await.result(f, Duration(1, SECONDS)) + assert(source.releaseCount == 1) + assert(sink.releaseCount == 1) + assert(a.destroyCount == 1) + assert(b.destroyCount == 1) + } +} + +@RunWith(classOf[JUnit4]) +class PipeSourceSinkTest { + def throwsIOException(f: => Unit) = { + try { f; false } + catch { case _: IOException => true } + } + + class PipeSink extends Process.PipeSink("TestPipeSink") { + def ensureRunloopStarted() = { + while (sink.size() > 0) { + Thread.sleep(1) + } + } + def isReleased = { + val field = classOf[Process.PipeSink].getDeclaredField("pipe") + field.setAccessible(true) + val pipe = field.get(this).asInstanceOf[PipedInputStream] + !this.isAlive && throwsIOException { pipe.read() } + } + } + + class PipeSource extends Process.PipeSource("TestPipeSource") { + def ensureRunloopStarted() = { + while (source.size() > 0) { + Thread.sleep(1) + } + } + def isReleased = { + val field = classOf[Process.PipeSource].getDeclaredField("pipe") + field.setAccessible(true) + val pipe = field.get(this).asInstanceOf[PipedOutputStream] + !this.isAlive && throwsIOException { pipe.write(1) } + } + } + + trait CloseChecking extends Closeable { + var closed = false + override def close() = closed = true + } + class DebugOutputStream extends ByteArrayOutputStream with CloseChecking + class DebugInputStream(s: String) extends ByteArrayInputStream(s.getBytes()) with CloseChecking + class DebugInfinityInputStream extends InputStream with CloseChecking { + def read() = 1 + } + + def sourceSink() = { + val source = new PipeSource + val sink = new PipeSink + source connectOut sink + source.start() + sink.start() + (source, sink) + } + + // PipeSource and PipeSink must release resources when it normally end + @Test + def normallyEnd() { + val in = new DebugInputStream("aaa") + val (source, sink) = sourceSink() + val out = new DebugOutputStream + source connectIn in + sink connectOut out + val f = Future { + source.join() + sink.join() + } + Await.result(f, Duration(1, SECONDS)) + assert(in.closed == true) + assert(out.closed == true) + assert(source.isReleased == true) + assert(sink.isReleased == true) + } + + // PipeSource and PipeSink must release resources when interrupted during waiting for source.take() + @Test + def sourceInterrupted() { + val (source, sink) = sourceSink() + val out = new DebugOutputStream + sink connectOut out + val f = Future { + sink.ensureRunloopStarted() + source.release() + sink.release() + } + Await.result(f, Duration(1, SECONDS)) + assert(out.closed == true) + assert(source.isReleased == true) + assert(sink.isReleased == true) + } + + // PipeSource and PipeSink must release resources when interrupted during waiting for sink.take() + @Test + def sinkInterrupted() { + val in = new DebugInputStream("aaa") + val (source, sink) = sourceSink() + source connectIn in + val f = Future { + source.ensureRunloopStarted() + source.release() + sink.release() + } + Await.result(f, Duration(1, SECONDS)) + assert(in.closed == true) + assert(source.isReleased == true) + assert(sink.isReleased == true) + } + + // PipeSource and PipeSink must release resources when interrupted during copy streams" + @Test + def runloopInterrupted() { + val in = new DebugInfinityInputStream + val (source, sink) = sourceSink() + val out = new DebugOutputStream + source connectIn in + sink connectOut out + val f = Future { + source.ensureRunloopStarted() + sink.ensureRunloopStarted() + source.release() + sink.release() + } + Await.result(f, Duration(1, SECONDS)) + assert(in.closed == true) + assert(out.closed == true) + assert(source.isReleased == true) + assert(sink.isReleased == true) + } +} From 9519eb094130ab121fa10767916e812b76bdc947 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Tue, 26 Aug 2014 09:43:49 +0200 Subject: [PATCH 503/826] SI-5254 running an empty scala script should succeed The script runner made the assumption that "compilation succeeded" implies "there is a Main class to run", but this can be wrong if the script is empty (or only contains imports/comments). The ScriptRunner now uses the ClassPath utility to check if there really is a main class. If not, it doesn't try to run it and returns peacefully. This also makes `scala -e ''` succeed. --- .../scala/tools/nsc/ScriptRunner.scala | 34 +++++++++++++------ .../scala/tools/nsc/ScriptRunnerTest.scala | 23 +++++++++++++ 2 files changed, 46 insertions(+), 11 deletions(-) create mode 100644 test/junit/scala/tools/nsc/ScriptRunnerTest.scala diff --git a/src/compiler/scala/tools/nsc/ScriptRunner.scala b/src/compiler/scala/tools/nsc/ScriptRunner.scala index c2d62db5585a..7d5c6f6fff77 100644 --- a/src/compiler/scala/tools/nsc/ScriptRunner.scala +++ b/src/compiler/scala/tools/nsc/ScriptRunner.scala @@ -6,7 +6,7 @@ package scala package tools.nsc -import io.{ Directory, File, Path } +import io.{ AbstractFile, Directory, File, Path } import java.io.IOException import scala.tools.nsc.reporters.{Reporter,ConsoleReporter} import util.Exceptional.unwrap @@ -111,6 +111,12 @@ class ScriptRunner extends HasCompileSocket { else None } + def hasClassToRun(d: Directory): Boolean = { + import util.ClassPath.{ DefaultJavaContext => ctx } + val cp = ctx.newClassPath(AbstractFile.getDirectory(d)) + cp.findClass(mainClass).isDefined + } + /* The script runner calls sys.exit to communicate a return value, but this must * not take place until there are no non-daemon threads running. Tickets #1955, #2006. */ @@ -124,15 +130,21 @@ class ScriptRunner extends HasCompileSocket { compile match { case Some(compiledPath) => - try io.Jar.create(jarFile, compiledPath, mainClass) - catch { case _: Exception => jarFile.delete() } - - if (jarOK) { - compiledPath.deleteRecursively() - handler(jarFile.toAbsolute.path) + if (!hasClassToRun(compiledPath)) { + // it compiled ok, but there is nothing to run; + // running an empty script should succeed + true + } else { + try io.Jar.create(jarFile, compiledPath, mainClass) + catch { case _: Exception => jarFile.delete() } + + if (jarOK) { + compiledPath.deleteRecursively() + handler(jarFile.toAbsolute.path) + } + // jar failed; run directly from the class files + else handler(compiledPath.path) } - // jar failed; run directly from the class files - else handler(compiledPath.path) case _ => false } } @@ -140,8 +152,8 @@ class ScriptRunner extends HasCompileSocket { if (jarOK) handler(jarFile.toAbsolute.path) // pre-compiled jar is current else recompile() // jar old - recompile the script. } - // don't use a cache jar at all--just use the class files - else compile exists (cp => handler(cp.path)) + // don't use a cache jar at all--just use the class files, if they exist + else compile exists (cp => !hasClassToRun(cp) || handler(cp.path)) } } diff --git a/test/junit/scala/tools/nsc/ScriptRunnerTest.scala b/test/junit/scala/tools/nsc/ScriptRunnerTest.scala new file mode 100644 index 000000000000..9bae7a0487f2 --- /dev/null +++ b/test/junit/scala/tools/nsc/ScriptRunnerTest.scala @@ -0,0 +1,23 @@ +package scala.tools.nsc + +import org.junit.Assert._ +import org.junit.Test +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 + +@RunWith(classOf[JUnit4]) +class ScriptRunnerTest { + @Test + def testEmptyScriptSucceeds: Unit = { + val s = new GenericRunnerSettings(s => ()) + s.nc.value = true + s.usejavacp.value = true + + // scala -nc -e '' + assertTrue(ScriptRunner.runCommand(s, "", Nil)) + + // scala -nc -save -e '' + s.save.value = true + assertTrue(ScriptRunner.runCommand(s, "", Nil)) + } +} From 887622759d302dbe8cb40cca7debe6d2bfffcaee Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Thu, 21 Aug 2014 00:53:02 -0700 Subject: [PATCH 504/826] [backport] SI-8787 Backport Regex doc Backport the doc with two material changes: 1. need to use Groups to extract from Match, so say that in lieu of the 2.11 advice that the Regex instance can be used without recomputing the match; 2. and relatedly, in 2.10 there is no secondary constructor, so the doc for group names is moved back up to the class doc. Original doc update on PR #3923 was: 0e26910372d349c6ff7bbaa17fc8fe0bf568c5fe f98c53cb03f800b3d790f3866ab90f827fd131f5 --- src/library/scala/util/matching/Regex.scala | 477 ++++++++++++-------- 1 file changed, 291 insertions(+), 186 deletions(-) diff --git a/src/library/scala/util/matching/Regex.scala b/src/library/scala/util/matching/Regex.scala index 716d746552c1..8d82e08d7f42 100644 --- a/src/library/scala/util/matching/Regex.scala +++ b/src/library/scala/util/matching/Regex.scala @@ -1,12 +1,11 @@ /* __ *\ ** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2007-2013, LAMP/EPFL ** +** / __/ __// _ | / / / _ | (c) 2007-2014, LAMP/EPFL ** ** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - /** * This package is concerned with regular expression (regex) matching against strings, * with the main goal of pulling out information from those matches, or replacing @@ -33,97 +32,132 @@ package scala.util.matching import scala.collection.AbstractIterator import java.util.regex.{ Pattern, Matcher } -/** This class provides methods for creating and using regular expressions. - * It is based on the regular expressions of the JDK since 1.4. +/** A regular expression is used to determine whether a string matches a pattern + * and, if it does, to extract or transform the parts that match. * - * Its main goal is to extract strings that match a pattern, or the subgroups - * that make it up. For that reason, it is usually used with for comprehensions - * and matching (see methods for examples). + * This class delegates to the [[java.util.regex]] package of the Java Platform. + * See the documentation for [[java.util.regex.Pattern]] for details about + * the regular expression syntax for pattern strings. * - * A Regex is created from a [[java.lang.String]] representation of the - * regular expression pattern^1^. That pattern is compiled - * during construction, so frequently used patterns should be declared outside - * loops if performance is of concern. Possibly, they might be declared on a - * companion object, so that they need only to be initialized once. + * An instance of `Regex` represents a compiled regular expression pattern. + * Since compilation is expensive, frequently used `Regex`es should be constructed + * once, outside of loops and perhaps in a companion object. * - * The canonical way of creating regex patterns is by using the method `r`, provided - * on [[java.lang.String]] through an implicit conversion into - * [[scala.collection.immutable.WrappedString]]. Using triple quotes to write these - * strings avoids having to quote the backslash character (`\`). + * The canonical way to create a `Regex` is by using the method `r`, provided + * implicitly for strings: * - * Using the constructor directly, on the other hand, makes - * it possible to declare names for subgroups in the pattern. + * {{{ + * val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r + * }}} * - * For example, both declarations below generate the same regex, but the second - * one associate names with the subgroups. + * Since escapes are not processed in multi-line string literals, using triple quotes + * avoids having to escape the backslash character, so that `"\\d"` can be written `"""\d"""`. + * + * To extract the capturing groups when a `Regex` is matched, use it as + * an extractor in a pattern match: * * {{{ - * val dateP1 = """(\d\d\d\d)-(\d\d)-(\d\d)""".r - * val dateP2 = new scala.util.matching.Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day") + * "2004-01-20" match { + * case date(year, month, day) => s"$year was a good year for PLs." + * } * }}} * - * There are two ways of using a `Regex` to find a pattern: calling methods on - * Regex, such as `findFirstIn` or `findAllIn`, or using it as an extractor in a - * pattern match. + * To check only whether the `Regex` matches, ignoring any groups, + * use a sequence wildcard: * - * Note, however, that when Regex is used as an extractor in a pattern match, it - * only succeeds if the whole text can be matched. For this reason, one usually - * calls a method to find the matching substrings, and then use it as an extractor - * to break match into subgroups. + * {{{ + * "2004-01-20" match { + * case date(_*) => "It's a date!" + * } + * }}} * - * As an example, the above patterns can be used like this: + * That works because a `Regex` extractor produces a sequence of strings. + * Extracting only the year from a date could also be expressed with + * a sequence wildcard: * * {{{ - * val dateP1(year, month, day) = "2011-07-15" + * "2004-01-20" match { + * case date(year, _*) => s"$year was a good year for PLs." + * } + * }}} * - * // val dateP1(year, month, day) = "Date 2011-07-15" // throws an exception at runtime + * In a pattern match, `Regex` normally matches the entire input. + * However, an unanchored `Regex` finds the pattern anywhere + * in the input. * - * val copyright: String = dateP1 findFirstIn "Date of this document: 2011-07-15" match { - * case Some(dateP1(year, month, day)) => "Copyright "+year - * case None => "No copyright" + * {{{ + * val embeddedDate = date.unanchored + * "Date: 2004-01-20 17:25:18 GMT (10 years, 28 weeks, 5 days, 17 hours and 51 minutes ago)" match { + * case embeddedDate("2004", "01", "20") => "A Scala is born." * } + * }}} * - * val copyright: Option[String] = for { - * dateP1(year, month, day) <- dateP1 findFirstIn "Last modified 2011-07-15" - * } yield year - - * def getYears(text: String): Iterator[String] = for (dateP1(year, _, _) <- dateP1 findAllIn text) yield year - * def getFirstDay(text: String): Option[String] = for (m <- dateP2 findFirstMatchIn text) yield m group "day" + * To find or replace matches of the pattern, use the various find and replace methods. + * There is a flavor of each method that produces matched strings and + * another that produces `Match` objects. + * + * For example, pattern matching with an unanchored `Regex`, as in the previous example, + * is the same as using `findFirstMatchIn`, except that the findFirst methods return an `Option`, + * or `None` for no match: + * + * {{{ + * val dates = "Important dates in history: 2004-01-20, 1958-09-05, 2010-10-06, 2011-07-15" + * val firstDate = date findFirstIn dates getOrElse "No date found." + * val firstYear = for (m <- date findFirstMatchIn dates) yield m group 1 * }}} * - * Regex does not provide a method that returns a [[scala.Boolean]]. One can - * use [[java.lang.String]] `matches` method, or, if `Regex` is preferred, - * either ignore the return value or test the `Option` for emptyness. For example: + * To find all matches: * * {{{ - * def hasDate(text: String): Boolean = (dateP1 findFirstIn text).nonEmpty - * def printLinesWithDates(lines: Traversable[String]) { - * lines foreach { line => - * dateP1 findFirstIn line foreach { _ => println(line) } - * } - * } + * val allYears = for (m <- date findAllMatchIn dates) yield m group 1 + * }}} + * + * But `findAllIn` returns a special iterator of strings that can be queried for the `MatchData` + * of the last match: + * + * {{{ + * val mi = date findAllIn dates + * val oldies = mi filter (_ => (mi group 1).toInt < 1960) map (s => s"$s: An oldie but goodie.") + * }}} + * + * Note that `findAllIn` finds matches that don't overlap. (See [[findAllIn]] for more examples.) + * + * {{{ + * val num = """(\d+)""".r + * val all = (num findAllIn "123").toList // List("123"), not List("123", "23", "3") + * }}} + * + * Text replacement can be performed unconditionally or as a function of the current match: + * + * {{{ + * val redacted = date replaceAllIn (dates, "XXXX-XX-XX") + * val yearsOnly = date replaceAllIn (dates, m => m group 1) + * val months = (0 to 11) map { i => val c = Calendar.getInstance; c.set(2014, i, 1); f"$c%tb" } + * val reformatted = date replaceAllIn (dates, _ match { case Groups(y,m,d) => f"${months(m.toInt - 1)} $d, $y" }) + * }}} + * + * The `Groups` extractor is used to extract groups from a `Match` without reapplying the `Regex`. + * In the expression for `reformatted`, each `date` match is computed once. But it is possible to apply a + * `Regex` to a `Match` resulting from a different pattern: + * + * {{{ + * val docSpree = """2011(?:-\d{2}){2}""".r + * val docView = date replaceAllIn (dates, _ match { + * case docSpree() => "Historic doc spree!" + * case _ => "Something else happened" + * }) * }}} * - * There are also methods that can be used to replace the patterns - * on a text. The substitutions can be simple replacements, or more - * complex functions. For example: + * If group names are supplied to the `Regex` constructor, they can be used this way: * * {{{ - * val months = Map( 1 -> "Jan", 2 -> "Feb", 3 -> "Mar", - * 4 -> "Apr", 5 -> "May", 6 -> "Jun", - * 7 -> "Jul", 8 -> "Aug", 9 -> "Sep", - * 10 -> "Oct", 11 -> "Nov", 12 -> "Dec") - * - * import scala.util.matching.Regex.Match - * def reformatDate(text: String) = dateP2 replaceAllIn ( text, (m: Match) => - * "%s %s, %s" format (months(m group "month" toInt), m group "day", m group "year") - * ) + * val namedDate = new Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day") + * val namedYears = for (m <- namedDate findAllMatchIn dates) yield m group "year" * }}} * - * You can use special pattern syntax constructs like `(?idmsux-idmsux)`¹ to switch - * various regex compilation options like `CASE_INSENSITIVE` or `UNICODE_CASE`. + * This constructor does not support options as flags, which must be + * supplied as inline flags in the pattern string: `(?idmsux-idmsux)`. * - * @note ¹ A detailed description is available in [[java.util.regex.Pattern]]. * @see [[java.util.regex.Pattern]] * * @author Thibaud Hottelier @@ -139,9 +173,8 @@ import java.util.regex.{ Pattern, Matcher } * interpreted as a reference to a group in the matched pattern, with numbers * 1 through 9 corresponding to the first nine groups, and 0 standing for the * whole match. Any other character is an error. The backslash (`\`) character - * will be interpreted as an escape character, and can be used to escape the - * dollar sign. One can use [[scala.util.matching.Regex]]'s `quoteReplacement` - * to automatically escape these characters. + * will be interpreted as an escape character and can be used to escape the + * dollar sign. Use `Regex.quoteReplacement` to escape these characters. */ @SerialVersionUID(-2094783597747625537L) class Regex(regex: String, groupNames: String*) extends Serializable { @@ -152,30 +185,60 @@ class Regex(regex: String, groupNames: String*) extends Serializable { /** The compiled pattern */ val pattern = Pattern.compile(regex) - /** Tries to match target (whole match) and returns the matching subgroups. - * if the pattern has no subgroups, then it returns an empty list on a - * successful match. + /** Tries to match either a [[java.lang.CharSequence]] or the matched + * input of a previous `Match`. * - * Note, however, that if some subgroup has not been matched, a `null` will - * be returned for that subgroup. + * If the match of a `CharSequence` succeeds, the result is a list of the capturing + * groups (with a `null` element if a group did not match any input). + * If the pattern specifies no groups, then the result will be an empty list + * on a successful match. + * + * This method attempts to match the entire input by default; to find the next + * matching subsequence, use an unanchored `Regex`. * * For example: * * {{{ * val p1 = "ab*c".r - * val p2 = "a(b*)c".r - * * val p1Matches = "abbbc" match { - * case p1() => true + * case p1() => true // no groups * case _ => false * } - * + * val p2 = "a(b*)c".r + * val p2Matches = "abbbc" match { + * case p2(_*) => true // any groups + * case _ => false + * } * val numberOfB = "abbbc" match { - * case p2(b) => Some(b.length) + * case p2(b) => Some(b.length) // one group * case _ => None * } + * val p3 = "b*".r.unanchored + * val p3Matches = "abbbc" match { + * case p3() => true // find the b's + * case _ => false + * } + * val p4 = "a(b*)(c+)".r + * val p4Matches = "abbbcc" match { + * case p4(_*) => true // multiple groups + * case _ => false + * } + * val allGroups = "abbbcc" match { + * case p4(all @ _*) => all mkString "/" // "bbb/cc" + * case _ => "" + * } + * val cGroup = "abbbcc" match { + * case p4(_, c) => c + * case _ => "" + * } * }}} * + * When matching a [[scala.util.matching.Regex.Match]], + * a previously failed match results in None. + * + * Otherwise, this `Regex` is applied to the previously matched input, + * and the result of that match is used. + * * @param target The string to match * @return The matches */ @@ -184,102 +247,127 @@ class Regex(regex: String, groupNames: String*) extends Serializable { val m = pattern matcher s if (runMatcher(m)) Some((1 to m.groupCount).toList map m.group) else None - case m: Match => unapplySeq(m.matched) - case _ => None + case m: Match => unapplySeq(m.matched) + case _ => None } + + // @see UnanchoredRegex protected def runMatcher(m: Matcher) = m.matches() - /** Return all matches of this regexp in given character sequence as a [[scala.util.matching.Regex.MatchIterator]], + /** Return all non-overlapping matches of this `Regex` in the given character + * sequence as a [[scala.util.matching.Regex.MatchIterator]], * which is a special [[scala.collection.Iterator]] that returns the - * matched strings, but can also be converted into a normal iterator - * that returns objects of type [[scala.util.matching.Regex.Match]] - * that can be queried for data such as the text that precedes the - * match, subgroups, etc. + * matched strings but can also be queried for more data about the last match, + * such as capturing groups and start position. + * + * A `MatchIterator` can also be converted into an iterator + * that returns objects of type [[scala.util.matching.Regex.Match]], + * such as is normally returned by `findAllMatchIn`. + * + * Where potential matches overlap, the first possible match is returned, + * followed by the next match that follows the input consumed by the + * first match: + * + * {{{ + * val hat = "hat[^a]+".r + * val hathaway = "hathatthattthatttt" + * val hats = (hat findAllIn hathaway).toList // List(hath, hattth) + * val pos = (hat findAllMatchIn hathaway map (_.start)).toList // List(0, 7) + * }}} + * + * To return overlapping matches, it is possible to formulate a regular expression + * with lookahead (`?=`) that does not consume the overlapping region. + * + * {{{ + * val madhatter = "(h)(?=(at[^a]+))".r + * val madhats = (madhatter findAllMatchIn hathaway map { + * case madhatter(x,y) => s"$x$y" + * }).toList // List(hath, hatth, hattth, hatttt) + * }}} + * + * Attempting to retrieve match information before performing the first match + * or after exhausting the iterator results in [[java.lang.IllegalStateException]]. + * See [[scala.util.matching.Regex.MatchIterator]] for details. * * @param source The text to match against. - * @return A [[scala.util.matching.Regex.MatchIterator]] of all matches. + * @return A [[scala.util.matching.Regex.MatchIterator]] of matched substrings. * @example {{{for (words <- """\w+""".r findAllIn "A simple example.") yield words}}} */ - def findAllIn(source: java.lang.CharSequence) = new Regex.MatchIterator(source, this, groupNames) + def findAllIn(source: CharSequence) = new Regex.MatchIterator(source, this, groupNames) - - /** Return all matches of this regexp in given character sequence as a + /** Return all non-overlapping matches of this regexp in given character sequence as a * [[scala.collection.Iterator]] of [[scala.util.matching.Regex.Match]]. * * @param source The text to match against. * @return A [[scala.collection.Iterator]] of [[scala.util.matching.Regex.Match]] for all matches. * @example {{{for (words <- """\w+""".r findAllMatchIn "A simple example.") yield words.start}}} */ - def findAllMatchIn(source: java.lang.CharSequence): Iterator[Match] = { + def findAllMatchIn(source: CharSequence): Iterator[Match] = { val matchIterator = findAllIn(source) new Iterator[Match] { def hasNext = matchIterator.hasNext def next: Match = { - matchIterator.next; + matchIterator.next() new Match(matchIterator.source, matchIterator.matcher, matchIterator.groupNames).force } } } - /** Return optionally first matching string of this regexp in given character sequence, - * or None if it does not exist. + /** Return an optional first matching string of this `Regex` in the given character sequence, + * or None if there is no match. * * @param source The text to match against. * @return An [[scala.Option]] of the first matching string in the text. * @example {{{"""\w+""".r findFirstIn "A simple example." foreach println // prints "A"}}} */ - def findFirstIn(source: java.lang.CharSequence): Option[String] = { + def findFirstIn(source: CharSequence): Option[String] = { val m = pattern.matcher(source) if (m.find) Some(m.group) else None } - /** Return optionally first match of this regexp in given character sequence, + /** Return an optional first match of this `Regex` in the given character sequence, * or None if it does not exist. * - * The main difference between this method and `findFirstIn` is that the (optional) return - * type for this is [[scala.util.matching.Regex.Match]], through which more - * data can be obtained about the match, such as the strings that precede and follow it, - * or subgroups. + * If the match is successful, the [[scala.util.matching.Regex.Match]] can be queried for + * more data. * * @param source The text to match against. * @return A [[scala.Option]] of [[scala.util.matching.Regex.Match]] of the first matching string in the text. * @example {{{("""[a-z]""".r findFirstMatchIn "A simple example.") map (_.start) // returns Some(2), the index of the first match in the text}}} */ - def findFirstMatchIn(source: java.lang.CharSequence): Option[Match] = { + def findFirstMatchIn(source: CharSequence): Option[Match] = { val m = pattern.matcher(source) if (m.find) Some(new Match(source, m, groupNames)) else None } - /** Return optionally match of this regexp at the beginning of the - * given character sequence, or None if regexp matches no prefix + /** Return an optional match of this `Regex` at the beginning of the + * given character sequence, or None if it matches no prefix * of the character sequence. * - * The main difference from this method to `findFirstIn` is that this - * method will not return any matches that do not begin at the start - * of the text being matched against. + * Unlike `findFirstIn`, this method will only return a match at + * the beginning of the input. * * @param source The text to match against. * @return A [[scala.Option]] of the matched prefix. - * @example {{{"""[a-z]""".r findPrefixOf "A simple example." // returns None, since the text does not begin with a lowercase letter}}} + * @example {{{"""\p{Lower}""".r findPrefixOf "A simple example." // returns None, since the text does not begin with a lowercase letter}}} */ - def findPrefixOf(source: java.lang.CharSequence): Option[String] = { + def findPrefixOf(source: CharSequence): Option[String] = { val m = pattern.matcher(source) if (m.lookingAt) Some(m.group) else None } - /** Return optionally match of this regexp at the beginning of the - * given character sequence, or None if regexp matches no prefix + /** Return an optional match of this `Regex` at the beginning of the + * given character sequence, or None if it matches no prefix * of the character sequence. * - * The main difference from this method to `findFirstMatchIn` is that - * this method will not return any matches that do not begin at the - * start of the text being matched against. + * Unlike `findFirstMatchIn`, this method will only return a match at + * the beginning of the input. * * @param source The text to match against. * @return A [[scala.Option]] of the [[scala.util.matching.Regex.Match]] of the matched string. * @example {{{"""\w+""".r findPrefixMatchOf "A simple example." map (_.after) // returns Some(" simple example.")}}} */ - def findPrefixMatchOf(source: java.lang.CharSequence): Option[Match] = { + def findPrefixMatchOf(source: CharSequence): Option[Match] = { val m = pattern.matcher(source) if (m.lookingAt) Some(new Match(source, m, groupNames)) else None } @@ -293,7 +381,7 @@ class Regex(regex: String, groupNames: String*) extends Serializable { * @return The resulting string * @example {{{"""\d+""".r replaceAllIn ("July 15", "") // returns "July "}}} */ - def replaceAllIn(target: java.lang.CharSequence, replacement: String): String = { + def replaceAllIn(target: CharSequence, replacement: String): String = { val m = pattern.matcher(target) m.replaceAll(replacement) } @@ -307,7 +395,7 @@ class Regex(regex: String, groupNames: String*) extends Serializable { * import scala.util.matching.Regex * val datePattern = new Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day") * val text = "From 2011-07-15 to 2011-07-17" - * val repl = datePattern replaceAllIn (text, m => m.group("month")+"/"+m.group("day")) + * val repl = datePattern replaceAllIn (text, m => s"${m group "month"}/${m group "day"}") * }}} * * $replacementString @@ -316,7 +404,7 @@ class Regex(regex: String, groupNames: String*) extends Serializable { * @param replacer The function which maps a match to another string. * @return The target string after replacements. */ - def replaceAllIn(target: java.lang.CharSequence, replacer: Match => String): String = { + def replaceAllIn(target: CharSequence, replacer: Match => String): String = { val it = new Regex.MatchIterator(target, this, groupNames).replacementData it foreach (md => it replace replacer(md)) it.replaced @@ -330,10 +418,10 @@ class Regex(regex: String, groupNames: String*) extends Serializable { * {{{ * import scala.util.matching.Regex._ * - * val map = Map("x" -> "a var", "y" -> """some $ and \ signs""") + * val vars = Map("x" -> "a var", "y" -> """some $ and \ signs""") * val text = "A text with variables %x, %y and %z." * val varPattern = """%(\w+)""".r - * val mapper = (m: Match) => map get (m group 1) map (quoteReplacement(_)) + * val mapper = (m: Match) => vars get (m group 1) map (quoteReplacement(_)) * val repl = varPattern replaceSomeIn (text, mapper) * }}} * @@ -343,7 +431,7 @@ class Regex(regex: String, groupNames: String*) extends Serializable { * @param replacer The function which optionally maps a match to another string. * @return The target string after replacements. */ - def replaceSomeIn(target: java.lang.CharSequence, replacer: Match => Option[String]): String = { + def replaceSomeIn(target: CharSequence, replacer: Match => Option[String]): String = { val it = new Regex.MatchIterator(target, this, groupNames).replacementData for (matchdata <- it ; replacement <- replacer(matchdata)) it replace replacement @@ -359,7 +447,7 @@ class Regex(regex: String, groupNames: String*) extends Serializable { * @param replacement The string that will replace the match * @return The resulting string */ - def replaceFirstIn(target: java.lang.CharSequence, replacement: String): String = { + def replaceFirstIn(target: CharSequence, replacement: String): String = { val m = pattern.matcher(target) m.replaceFirst(replacement) } @@ -370,21 +458,29 @@ class Regex(regex: String, groupNames: String*) extends Serializable { * @return The array of strings computed by splitting the * input around matches of this regexp */ - def split(toSplit: java.lang.CharSequence): Array[String] = + def split(toSplit: CharSequence): Array[String] = pattern.split(toSplit) /** Create a new Regex with the same pattern, but no requirement that - * the entire String matches in extractor patterns. For instance, the strings - * shown below lead to successful matches, where they would not otherwise. + * the entire String matches in extractor patterns. + * + * Normally, matching on `date` behaves as though the pattern were + * enclosed in anchors, `"^pattern$"`. + * + * The unanchored `Regex` behaves as though those anchors were removed. + * + * Note that this method does not actually strip any matchers from the pattern. + * + * Calling `anchored` returns the original `Regex`. * * {{{ - * val dateP1 = """(\d\d\d\d)-(\d\d)-(\d\d)""".r.unanchored + * val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r.unanchored * - * val dateP1(year, month, day) = "Date 2011-07-15" + * val date(year, month, day) = "Date 2011-07-15" // OK * * val copyright: String = "Date of this document: 2011-07-15" match { - * case dateP1(year, month, day) => "Copyright "+year - * case _ => "No copyright" + * case date(year, month, day) => s"Copyright $year" // OK + * case _ => "No copyright" * } * }}} * @@ -397,93 +493,96 @@ class Regex(regex: String, groupNames: String*) extends Serializable { override def toString = regex } +/** A [[Regex]] that finds the first match when used in a pattern match. + * + * @see [[Regex#unanchored]] + */ trait UnanchoredRegex extends Regex { override protected def runMatcher(m: Matcher) = m.find() override def unanchored = this } /** This object defines inner classes that describe - * regex matches and helper objects. The class hierarchy - * is as follows: - * - * {{{ - * MatchData - * / \ - * MatchIterator Match - * }}} - * + * regex matches and helper objects. */ object Regex { - /** This class provides methods to access - * the details of a match. - */ + /** This class provides methods to access the details of a match. */ trait MatchData { - /** The source from where the match originated */ - val source: java.lang.CharSequence + /** The source from which the match originated */ + val source: CharSequence - /** The names of the groups, or some empty sequence if one defined */ + /** The names of the groups, or an empty sequence if none defined */ val groupNames: Seq[String] - /** The number of subgroups in the pattern (not all of these need to match!) */ + /** The number of capturing groups in the pattern. + * (For a given successful match, some of those groups may not have matched any input.) + */ def groupCount: Int /** The index of the first matched character, or -1 if nothing was matched */ def start: Int /** The index of the first matched character in group `i`, - * or -1 if nothing was matched for that group */ + * or -1 if nothing was matched for that group. + */ def start(i: Int): Int - /** The index of the last matched character, or -1 if nothing was matched */ + /** The index following the last matched character, or -1 if nothing was matched. */ def end: Int /** The index following the last matched character in group `i`, - * or -1 if nothing was matched for that group */ + * or -1 if nothing was matched for that group. + */ def end(i: Int): Int - /** The matched string, or `null` if nothing was matched */ + /** The matched string, or `null` if nothing was matched. */ def matched: String = if (start >= 0) source.subSequence(start, end).toString else null /** The matched string in group `i`, - * or `null` if nothing was matched */ + * or `null` if nothing was matched. + */ def group(i: Int): String = if (start(i) >= 0) source.subSequence(start(i), end(i)).toString else null - /** All matched subgroups, i.e. not including group(0) */ + /** All capturing groups, i.e., not including group(0). */ def subgroups: List[String] = (1 to groupCount).toList map group /** The char sequence before first character of match, - * or `null` if nothing was matched */ - def before: java.lang.CharSequence = + * or `null` if nothing was matched. + */ + def before: CharSequence = if (start >= 0) source.subSequence(0, start) else null /** The char sequence before first character of match in group `i`, - * or `null` if nothing was matched for that group */ - def before(i: Int): java.lang.CharSequence = + * or `null` if nothing was matched for that group. + */ + def before(i: Int): CharSequence = if (start(i) >= 0) source.subSequence(0, start(i)) else null /** Returns char sequence after last character of match, - * or `null` if nothing was matched */ - def after: java.lang.CharSequence = + * or `null` if nothing was matched. + */ + def after: CharSequence = if (end >= 0) source.subSequence(end, source.length) else null /** The char sequence after last character of match in group `i`, - * or `null` if nothing was matched for that group */ - def after(i: Int): java.lang.CharSequence = + * or `null` if nothing was matched for that group. + */ + def after(i: Int): CharSequence = if (end(i) >= 0) source.subSequence(end(i), source.length) else null private lazy val nameToIndex: Map[String, Int] = Map[String, Int]() ++ ("" :: groupNames.toList).zipWithIndex - /** Returns the group with given name + /** Returns the group with given name. * * @param id The group name * @return The requested group @@ -494,24 +593,22 @@ object Regex { case Some(index) => group(index) } - /** The matched string; equivalent to `matched.toString` */ + /** The matched string; equivalent to `matched.toString`. */ override def toString = matched - } - /** Provides information about a succesful match. - */ - class Match(val source: java.lang.CharSequence, + /** Provides information about a successful match. */ + class Match(val source: CharSequence, matcher: Matcher, val groupNames: Seq[String]) extends MatchData { - /** The index of the first matched character */ + /** The index of the first matched character. */ val start = matcher.start - /** The index following the last matched character */ + /** The index following the last matched character. */ val end = matcher.end - /** The number of subgroups */ + /** The number of subgroups. */ def groupCount = matcher.groupCount private lazy val starts: Array[Int] = @@ -519,19 +616,19 @@ object Regex { private lazy val ends: Array[Int] = ((0 to groupCount) map matcher.end).toArray - /** The index of the first matched character in group `i` */ + /** The index of the first matched character in group `i`. */ def start(i: Int) = starts(i) - /** The index following the last matched character in group `i` */ + /** The index following the last matched character in group `i`. */ def end(i: Int) = ends(i) /** The match itself with matcher-dependent lazy vals forced, - * so that match is valid even once matcher is advanced + * so that match is valid even once matcher is advanced. */ def force: this.type = { starts; ends; this } } - /** An extractor object for Matches, yielding the matched string + /** An extractor object for Matches, yielding the matched string. * * This can be used to help writing replacer functions when you * are not interested in match data. For example: @@ -546,24 +643,32 @@ object Regex { def unapply(m: Match): Some[String] = Some(m.matched) } - /** An extractor object that yields the groups in the match. Using an extractor - * rather than the original regex avoids recomputing the match. + /** An extractor object that yields the groups in the match. Using this extractor + * rather than the original `Regex` ensures that the match is not recomputed. * * {{{ * import scala.util.matching.Regex.Groups * - * val datePattern = """(\d\d\d\d)-(\d\d)-(\d\d)""".r + * val date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r * val text = "The doc spree happened on 2011-07-15." - * val day = datePattern replaceAllIn(text, _ match { case Groups(year, month, day) => month+"/"+day }) + * val day = date replaceAllIn(text, _ match { case Groups(_, month, day) => s"$month/$day" }) * }}} */ object Groups { def unapplySeq(m: Match): Option[Seq[String]] = if (m.groupCount > 0) Some(1 to m.groupCount map m.group) else None } - /** A class to step through a sequence of regex matches + /** A class to step through a sequence of regex matches. + * + * All methods inherited from [[scala.util.matching.Regex.MatchData]] will throw + * a [[java.lang.IllegalStateException]] until the matcher is initialized. The + * matcher can be initialized by calling `hasNext` or `next()` or causing these + * methods to be called, such as by invoking `toString` or iterating through + * the iterator's elements. + * + * @see [[java.util.regex.Matcher]] */ - class MatchIterator(val source: java.lang.CharSequence, val regex: Regex, val groupNames: Seq[String]) + class MatchIterator(val source: CharSequence, val regex: Regex, val groupNames: Seq[String]) extends AbstractIterator[String] with Iterator[String] with MatchData { self => protected[Regex] val matcher = regex.pattern.matcher(source) @@ -575,7 +680,7 @@ object Regex { nextSeen } - /** The next matched substring of `source` */ + /** The next matched substring of `source`. */ def next(): String = { if (!hasNext) throw new NoSuchElementException nextSeen = false @@ -584,32 +689,32 @@ object Regex { override def toString = super[AbstractIterator].toString - /** The index of the first matched character */ + /** The index of the first matched character. */ def start: Int = matcher.start - /** The index of the first matched character in group `i` */ + /** The index of the first matched character in group `i`. */ def start(i: Int): Int = matcher.start(i) - /** The index of the last matched character */ + /** The index of the last matched character. */ def end: Int = matcher.end - /** The index following the last matched character in group `i` */ + /** The index following the last matched character in group `i`. */ def end(i: Int): Int = matcher.end(i) - /** The number of subgroups */ + /** The number of subgroups. */ def groupCount = matcher.groupCount - /** Convert to an iterator that yields MatchData elements instead of Strings */ + /** Convert to an iterator that yields MatchData elements instead of Strings. */ def matchData: Iterator[Match] = new AbstractIterator[Match] { def hasNext = self.hasNext - def next = { self.next; new Match(source, matcher, groupNames).force } + def next = { self.next(); new Match(source, matcher, groupNames).force } } - /** Convert to an iterator that yields MatchData elements instead of Strings and has replacement support */ + /** Convert to an iterator that yields MatchData elements instead of Strings and has replacement support. */ private[matching] def replacementData = new AbstractIterator[Match] with Replacement { def matcher = self.matcher def hasNext = self.hasNext - def next = { self.next; new Match(source, matcher, groupNames).force } + def next = { self.next(); new Match(source, matcher, groupNames).force } } } From f6467d063167da3a34ac92957d3a308d2a230926 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Wed, 27 Aug 2014 01:18:52 +1000 Subject: [PATCH 505/826] SI-8823 Exclude specialized methods from extension method rewrite If a value class extends a specialized class, it can sprout specialized members after the specialization info transformer has run. However, we only install extension methods for class members we know about at the extmethods phase. This commit simply disables rewiring calls to these methods in erasure to an extention method. This follows the approach taken from super accessors. Note: value class type parameters themselves currently are not allowed to be specialized. --- src/reflect/scala/reflect/internal/Symbols.scala | 2 +- test/files/run/t8823.scala | 10 ++++++++++ 2 files changed, 11 insertions(+), 1 deletion(-) create mode 100644 test/files/run/t8823.scala diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala index b6cce4524b48..ac7d2343fa89 100644 --- a/src/reflect/scala/reflect/internal/Symbols.scala +++ b/src/reflect/scala/reflect/internal/Symbols.scala @@ -795,7 +795,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => info.firstParent.typeSymbol == AnyValClass && !isPrimitiveValueClass final def isMethodWithExtension = - isMethod && owner.isDerivedValueClass && !isParamAccessor && !isConstructor && !hasFlag(SUPERACCESSOR) && !isMacro + isMethod && owner.isDerivedValueClass && !isParamAccessor && !isConstructor && !hasFlag(SUPERACCESSOR) && !isMacro && !isSpecialized final def isAnonymousFunction = isSynthetic && (name containsName tpnme.ANON_FUN_NAME) final def isDefinedInPackage = effectiveOwner.isPackageClass diff --git a/test/files/run/t8823.scala b/test/files/run/t8823.scala new file mode 100644 index 000000000000..0ac653566a41 --- /dev/null +++ b/test/files/run/t8823.scala @@ -0,0 +1,10 @@ +class Tuple2Int(val encoding: Long) extends AnyVal with Product2[Int, Int] { + def canEqual(that: Any) = false + def _1: Int = 1 + def _2: Int = 2 +} + +object Test extends App { + assert(new Tuple2Int(0)._1 == 1) + assert(new Tuple2Int(0)._2 == 2) +} From 9276a1205f74fdec74206209712831913e93f359 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 26 Aug 2014 17:38:19 +0200 Subject: [PATCH 506/826] SI-8627 make Stream.filterNot non-eager The obvious fix, overriding `filterNot` in Stream, is not binary compatible, see https://github.com/scala/scala/pull/3925 Instead, this makes `filterImpl` in TaversableLike private[scala], which allows overriding it in Stream. The corresponding mima-failures can be whitelisted, as the changes are only to private[scala]. In 2.12.x we can remove the override of `filter` in Stream, but in 2.11.x this is not binary compatible. Eventually we'd also like to make filter / filterNot in TraversableLike final, but that's not source compatible, so it cannot be done in 2.12.x. --- bincompat-backward.whitelist.conf | 9 ++ bincompat-forward.whitelist.conf | 97 +++++++++++++++++++ .../scala/collection/TraversableLike.scala | 2 +- .../scala/collection/immutable/Stream.scala | 24 ++--- test/files/run/t4332.scala | 2 +- test/junit/scala/collection/StreamTest.scala | 18 ++++ 6 files changed, 139 insertions(+), 13 deletions(-) create mode 100644 test/junit/scala/collection/StreamTest.scala diff --git a/bincompat-backward.whitelist.conf b/bincompat-backward.whitelist.conf index ffacbf044283..1c48887b63a9 100644 --- a/bincompat-backward.whitelist.conf +++ b/bincompat-backward.whitelist.conf @@ -185,6 +185,15 @@ filter { { matchName="scala.reflect.runtime.SynchronizedOps.newNestedScope" problemName=MissingMethodProblem + }, + // see github.com/scala/scala/pull/3925, SI-8627, SI-6440 + { + matchName="scala.collection.TraversableLike.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.immutable.Stream.filteredTail" + problemName=MissingMethodProblem } ] } diff --git a/bincompat-forward.whitelist.conf b/bincompat-forward.whitelist.conf index 0b90cf4c8ba4..ec80e7cce951 100644 --- a/bincompat-forward.whitelist.conf +++ b/bincompat-forward.whitelist.conf @@ -271,6 +271,103 @@ filter { { matchName="scala.reflect.api.PredefTypeCreator" problemName=MissingClassProblem + }, + // see github.com/scala/scala/pull/3925, SI-8627, SI-6440 + { + matchName="scala.collection.IterableViewLike#AbstractTransformed.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.AbstractTraversable.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.TraversableViewLike#AbstractTransformed.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.TraversableLike.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.SeqViewLike#AbstractTransformed.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.immutable.TreeSet.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.immutable.Stream.filteredTail" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.immutable.Stream.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.immutable.Stream.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.immutable.StringOps.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.immutable.TreeMap.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.concurrent.TrieMap.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.mutable.ArrayOps#ofByte.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.mutable.ArrayOps#ofLong.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.mutable.ArrayOps#ofUnit.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.mutable.ArrayOps#ofInt.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.mutable.ArrayOps#ofChar.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.mutable.ArrayOps#ofRef.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.mutable.ArrayOps#ofDouble.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.mutable.ArrayOps#ofFloat.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.mutable.ArrayOps#ofBoolean.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.mutable.ArrayOps#ofShort.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.mutable.TreeSet.filterImpl" + problemName=MissingMethodProblem + }, + { + matchName="scala.reflect.io.AbstractFile.filterImpl" + problemName=MissingMethodProblem } ] } diff --git a/src/library/scala/collection/TraversableLike.scala b/src/library/scala/collection/TraversableLike.scala index d3a7db6968ea..a8731a51b16a 100644 --- a/src/library/scala/collection/TraversableLike.scala +++ b/src/library/scala/collection/TraversableLike.scala @@ -253,7 +253,7 @@ trait TraversableLike[+A, +Repr] extends Any b.result } - private def filterImpl(p: A => Boolean, isFlipped: Boolean): Repr = { + private[scala] def filterImpl(p: A => Boolean, isFlipped: Boolean): Repr = { val b = newBuilder for (x <- this) if (p(x) != isFlipped) b += x diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala index d3ff5e8abf42..f43f864e862f 100644 --- a/src/library/scala/collection/immutable/Stream.scala +++ b/src/library/scala/collection/immutable/Stream.scala @@ -468,6 +468,16 @@ self => ) else super.flatMap(f)(bf) + override private[scala] def filterImpl(p: A => Boolean, isFlipped: Boolean): Stream[A] = { + // optimization: drop leading prefix of elems for which f returns false + // var rest = this dropWhile (!p(_)) - forget DRY principle - GC can't collect otherwise + var rest = this + while (!rest.isEmpty && p(rest.head) == isFlipped) rest = rest.tail + // private utility func to avoid `this` on stack (would be needed for the lazy arg) + if (rest.nonEmpty) Stream.filteredTail(rest, p, isFlipped) + else Stream.Empty + } + /** Returns all the elements of this `Stream` that satisfy the predicate `p` * in a new `Stream` - i.e. it is still a lazy data structure. The order of * the elements is preserved @@ -481,15 +491,7 @@ self => * // produces * }}} */ - override def filter(p: A => Boolean): Stream[A] = { - // optimization: drop leading prefix of elems for which f returns false - // var rest = this dropWhile (!p(_)) - forget DRY principle - GC can't collect otherwise - var rest = this - while (!rest.isEmpty && !p(rest.head)) rest = rest.tail - // private utility func to avoid `this` on stack (would be needed for the lazy arg) - if (rest.nonEmpty) Stream.filteredTail(rest, p) - else Stream.Empty - } + override def filter(p: A => Boolean): Stream[A] = filterImpl(p, isFlipped = false) // This override is only left in 2.11 because of binary compatibility, see PR #3925 override final def withFilter(p: A => Boolean): StreamWithFilter = new StreamWithFilter(p) @@ -1187,8 +1189,8 @@ object Stream extends SeqFactory[Stream] { else cons(start, range(start + step, end, step)) } - private[immutable] def filteredTail[A](stream: Stream[A], p: A => Boolean) = { - cons(stream.head, stream.tail filter p) + private[immutable] def filteredTail[A](stream: Stream[A], p: A => Boolean, isFlipped: Boolean) = { + cons(stream.head, stream.tail.filterImpl(p, isFlipped)) } private[immutable] def collectedTail[A, B, That](head: B, stream: Stream[A], pf: PartialFunction[A, B], bf: CanBuildFrom[Stream[A], B, That]) = { diff --git a/test/files/run/t4332.scala b/test/files/run/t4332.scala index 5a67922911b7..1c7e7d73de66 100644 --- a/test/files/run/t4332.scala +++ b/test/files/run/t4332.scala @@ -12,7 +12,7 @@ object Test extends DirectTest { } def isExempt(sym: Symbol) = { - val exempt = Set("view", "repr", "sliceWithKnownDelta", "sliceWithKnownBound", "transform") + val exempt = Set("view", "repr", "sliceWithKnownDelta", "sliceWithKnownBound", "transform", "filterImpl") (exempt contains sym.name.decoded) } diff --git a/test/junit/scala/collection/StreamTest.scala b/test/junit/scala/collection/StreamTest.scala new file mode 100644 index 000000000000..6dc1c79a48d3 --- /dev/null +++ b/test/junit/scala/collection/StreamTest.scala @@ -0,0 +1,18 @@ +package scala.collection.immutable + +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 +import org.junit.Test +import org.junit.Assert._ + +@RunWith(classOf[JUnit4]) +class StreamTest { + + @Test + def t6727_and_t6440(): Unit = { + assertTrue(Stream.continually(()).filter(_ => true).take(2) == Seq((), ())) + assertTrue(Stream.continually(()).filterNot(_ => false).take(2) == Seq((), ())) + assertTrue(Stream(1,2,3,4,5).filter(_ < 4) == Seq(1,2,3)) + assertTrue(Stream(1,2,3,4,5).filterNot(_ > 4) == Seq(1,2,3,4)) + } +} From 997ef56058d8c44d2b9c5f561edf2aa65221c150 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Thu, 28 Aug 2014 10:40:05 +0200 Subject: [PATCH 507/826] SI-8828 fix regression in Xlint visibility warning for sealed classes 5dfcf5e reverted a change to `Symbol#isEffectivelyFinal` (made in adeffda) that broke overriding checks, and moved the new enhanced version to a new method. However, the test for inaccessible type access still uses the old one, so it lost the ability to see that the owner of some method is either final or sealed and not overridden. This just makes it use the new `isEffectivelyFinalOrNotOverriden`. --- .../tools/nsc/typechecker/RefChecks.scala | 2 +- test/files/pos/t8828.flags | 1 + test/files/pos/t8828.scala | 20 +++++++++++++++++++ 3 files changed, 22 insertions(+), 1 deletion(-) create mode 100644 test/files/pos/t8828.flags create mode 100644 test/files/pos/t8828.scala diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala index 47465875e933..1cb775959d6e 100644 --- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala +++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala @@ -1633,7 +1633,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans if (settings.warnNullaryUnit) checkNullaryMethodReturnType(sym) if (settings.warnInaccessible) { - if (!sym.isConstructor && !sym.isEffectivelyFinal && !sym.isSynthetic) + if (!sym.isConstructor && !sym.isEffectivelyFinalOrNotOverridden && !sym.isSynthetic) checkAccessibilityOfReferencedTypes(tree) } tree match { diff --git a/test/files/pos/t8828.flags b/test/files/pos/t8828.flags new file mode 100644 index 000000000000..e68991f64344 --- /dev/null +++ b/test/files/pos/t8828.flags @@ -0,0 +1 @@ +-Xlint:inaccessible -Xfatal-warnings diff --git a/test/files/pos/t8828.scala b/test/files/pos/t8828.scala new file mode 100644 index 000000000000..92092b4dd4fe --- /dev/null +++ b/test/files/pos/t8828.scala @@ -0,0 +1,20 @@ + +package outer + +package inner { + + private[inner] class A + + // the class is final: no warning + private[outer] final class B { + def doWork(a: A): A = a + } + + // the trait is sealed and doWork is not + // and cannot be overriden: no warning + private[outer] sealed trait C { + def doWork(a: A): A = a + } + + private[outer] final class D extends C +} From 7f21475c56b143f54491fb88041899366a281ee7 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Mon, 1 Sep 2014 04:39:50 -0700 Subject: [PATCH 508/826] SI-8410 Don't warn fatally on disabled flag Since boolean settings can now be set false by user, summary warnings should not be issued when the flag is explicitly off (as opposed to unset, default). In particular, `-Xfatal-warnings` should not fail if there were no warnings otherwise. ``` $ ~/scala-2.11.2/bin/scalac -d /tmp -deprecation:false test/files/pos/t8410.scala $ ~/scala-2.11.2/bin/scalac -d /tmp -deprecation:false -Xfatal-warnings test/files/pos/t8410.scala warning: there were three deprecation warnings; re-run with -deprecation for details error: No warnings can be incurred under -Xfatal-warnings. one warning found one error found ``` After this commit: ``` $ skalac -d /tmp -Xfatal-warnings test/files/pos/t8410.scala warning: there were three deprecation warnings; re-run with -deprecation for details error: No warnings can be incurred under -Xfatal-warnings. one warning found one error found $ skalac -d /tmp -deprecation:false -Xfatal-warnings test/files/pos/t8410.scala ``` Similarly for other collecting flags: ``` $ skalac -d /tmp -optimise -Yinline-warnings -deprecation:false -Xfatal-warnings test/files/pos/t8410.scala test/files/pos/t8410.scala:14: warning: Could not inline required method dropWhile because access level required by callee not matched by caller. def k = List(0).dropWhile(_ < 1) // inlining warns doubly ^ test/files/pos/t8410.scala:14: warning: At the end of the day, could not inline @inline-marked method dropWhile def k = List(0).dropWhile(_ < 1) // inlining warns doubly ^ error: No warnings can be incurred under -Xfatal-warnings. two warnings found one error found $ skalac -d /tmp -optimise -Yinline-warnings:false -deprecation:false -Xfatal-warnings test/files/pos/t8410.scala ``` Footnote: handling of deprecated locals also changed in 2014: ``` $ ~/scala-2.11.0-M7/bin/scalac -d /tmp -deprecation -Xfatal-warnings test/files/pos/t8410.scala test/files/pos/t8410.scala:8: warning: method f in object Test is deprecated: Console println f // warns ^ error: No warnings can be incurred under -Xfatal-warnings. one warning found one error found $ ~/scala-2.11.0-M8/bin/scalac -d /tmp -deprecation -Xfatal-warnings test/files/pos/t8410.scala test/files/pos/t8410.scala:5: warning: method _f is deprecated: def g = { @deprecated("","") def _f = f ; _f } // warns in 2.11.0-M8 ^ test/files/pos/t8410.scala:6: warning: class X is deprecated: def x = { @deprecated("","") class X { def x = f } ; new X().x } // warns in 2.11.0-M8 ^ test/files/pos/t8410.scala:8: warning: method f in object Test is deprecated: Console println f // warns ^ error: No warnings can be incurred under -Xfatal-warnings. three warnings found one error found ``` --- src/compiler/scala/tools/nsc/Reporting.scala | 9 ++++++--- test/files/pos/t8410.flags | 1 + test/files/pos/t8410.scala | 15 +++++++++++++++ 3 files changed, 22 insertions(+), 3 deletions(-) create mode 100644 test/files/pos/t8410.flags create mode 100644 test/files/pos/t8410.scala diff --git a/src/compiler/scala/tools/nsc/Reporting.scala b/src/compiler/scala/tools/nsc/Reporting.scala index b164f395fe55..6ae5ec3c1d5a 100644 --- a/src/compiler/scala/tools/nsc/Reporting.scala +++ b/src/compiler/scala/tools/nsc/Reporting.scala @@ -32,14 +32,17 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w def warn(pos: Position, msg: String) = if (option) reporter.warning(pos, msg) else if (!(warnings contains pos)) warnings += ((pos, msg)) - def summarize() = - if (warnings.nonEmpty && (option.isDefault || settings.fatalWarnings)) { + def summarize() = { + def turnedOff = option.isSetByUser && !option + def moreInfos = option.isDefault || settings.fatalWarnings + if (warnings.nonEmpty && !turnedOff && moreInfos) { val numWarnings = warnings.size val warningVerb = if (numWarnings == 1) "was" else "were" val warningCount = countElementsAsString(numWarnings, s"$what warning") reporter.warning(NoPosition, s"there $warningVerb $warningCount; re-run with ${option.name} for details") } + } } // This change broke sbt; I gave it the thrilling name of uncheckedWarnings0 so @@ -105,4 +108,4 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w reporter.error(NoPosition, "No warnings can be incurred under -Xfatal-warnings.") } } -} \ No newline at end of file +} diff --git a/test/files/pos/t8410.flags b/test/files/pos/t8410.flags new file mode 100644 index 000000000000..dcd5943c2f97 --- /dev/null +++ b/test/files/pos/t8410.flags @@ -0,0 +1 @@ +-optimise -Xfatal-warnings -deprecation:false -Yinline-warnings:false diff --git a/test/files/pos/t8410.scala b/test/files/pos/t8410.scala new file mode 100644 index 000000000000..4d862311fab5 --- /dev/null +++ b/test/files/pos/t8410.scala @@ -0,0 +1,15 @@ + +object Test extends App { + @deprecated("","") def f = 42 + @deprecated("","") def z = f + def g = { @deprecated("","") def _f = f ; _f } // warns in 2.11.0-M8 + def x = { @deprecated("","") class X { def x = f } ; new X().x } // warns in 2.11.0-M8 + Console println g + Console println f // warns + + @deprecated("","") trait T + object T extends T { def t = f } + Console println T.t + + def k = List(0).dropWhile(_ < 1) // inlining warns doubly +} From 2606bd921e434a6d8edb21f7f04dbfb10045026e Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 14 Aug 2014 23:40:37 +0200 Subject: [PATCH 509/826] Don't traverse all trees in delambdafy phase if delambdafy:inline If delambdafy:method is not enabled, the delambdafy method is a nop. --- src/compiler/scala/tools/nsc/transform/Delambdafy.scala | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala index 371061662e49..9cc8d779a0ff 100644 --- a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala +++ b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala @@ -37,6 +37,15 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre /** the following two members override abstract members in Transform */ val phaseName: String = "delambdafy" + override def newPhase(prev: scala.tools.nsc.Phase): StdPhase = { + if (settings.Ydelambdafy.value == "method") new Phase(prev) + else new SkipPhase(prev) + } + + class SkipPhase(prev: scala.tools.nsc.Phase) extends StdPhase(prev) { + def apply(unit: global.CompilationUnit): Unit = () + } + protected def newTransformer(unit: CompilationUnit): Transformer = new DelambdafyTransformer(unit) From e3107465c3e8ac80d1cc6a759e2f3298c2531424 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 1 Jul 2014 16:28:24 +0200 Subject: [PATCH 510/826] Fix InnerClass / EnclosingMethod attributes This commit seems bigger than it is. Most of it is tests, and moving some code around. The actual changes are small, but a bit subtle. The InnerClass and EnclosingMethod attributes should now be close to the JVM spec (which is summarized in BTypes.scala). New tests make sure that changes to these attributes, and changes to the way Java reflection sees Scala classfiles, don't go unnoticed. A new file, BCodeAsmCommon, holds code that's shared between the two backend (it could hold more, future work). In general, the difficulty with emitting InnerClass / EnclosingMethod is that we need to find out source-level properties. We need to make sure to do enough phase-travelling, and work around destructive changes to the ownerchain in lambdalift (we use originalOwner a lot). The change to JavaMirrors is prompted by the change to the EnclosingMethod attribute, which changes Java reflection's answer to getEnclosingMethod and getEnclosingConstructor. Classes defined in field initializers no longer have an enclosing method, just an enclosing class, which broke an assumption in JavaMirrors. There's one change in erasure. Before this change, when an object declaration implements / overrides a method, and a bridge is required, then the bridge method was actually a ModuleSymbol (it would get the lateMETHOD flag and be emitted as a method anyway). This is confusing, when iterating through the members of a class, you can find two modules with the same name, and one of them doesn't have a module class. Now, such bridge methods will be MethodSymbols. Removed Symbol.originalEnclosingMethod, that is a backend thing and doesn't need to live in the symbol API. --- src/compiler/scala/tools/nsc/Global.scala | 2 +- .../nsc/backend/jvm/BCodeAsmCommon.scala | 130 +++++++++ .../nsc/backend/jvm/BCodeBodyBuilder.scala | 2 +- .../tools/nsc/backend/jvm/BCodeHelpers.scala | 49 ---- .../nsc/backend/jvm/BCodeIdiomatic.scala | 2 - .../nsc/backend/jvm/BCodeSkelBuilder.scala | 9 +- .../scala/tools/nsc/backend/jvm/BTypes.scala | 62 +++-- .../nsc/backend/jvm/BTypesFromSymbols.scala | 102 ++++--- .../scala/tools/nsc/backend/jvm/GenASM.scala | 72 ++--- .../scala/tools/nsc/transform/Erasure.scala | 8 +- .../tools/nsc/transform/LambdaLift.scala | 2 + .../scala/tools/nsc/interactive/Global.scala | 2 - .../scala/reflect/internal/Symbols.scala | 20 -- .../scala/reflect/runtime/JavaMirrors.scala | 25 +- test/files/jvm/innerClassAttribute.check | 54 ++++ .../jvm/innerClassAttribute/Classes_1.scala | 92 ++++++- .../jvm/innerClassAttribute/Java_A_1.java | 10 + test/files/jvm/innerClassAttribute/Test.scala | 218 ++++++++++++--- test/files/jvm/javaReflection.check | 259 ++++++++++++++++++ test/files/jvm/javaReflection/Classes_1.scala | 84 ++++++ test/files/jvm/javaReflection/Test.scala | 137 +++++++++ test/files/run/t5256c.check | 2 +- versions.properties | 2 +- 23 files changed, 1090 insertions(+), 255 deletions(-) create mode 100644 src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala create mode 100644 test/files/jvm/innerClassAttribute.check create mode 100644 test/files/jvm/innerClassAttribute/Java_A_1.java create mode 100644 test/files/jvm/javaReflection.check create mode 100644 test/files/jvm/javaReflection/Classes_1.scala create mode 100644 test/files/jvm/javaReflection/Test.scala diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 08d2b89ece6b..0077e261cf50 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -1171,7 +1171,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) val erasurePhase = phaseNamed("erasure") val posterasurePhase = phaseNamed("posterasure") // val lazyvalsPhase = phaseNamed("lazyvals") - // val lambdaliftPhase = phaseNamed("lambdalift") + val lambdaliftPhase = phaseNamed("lambdalift") // val constructorsPhase = phaseNamed("constructors") val flattenPhase = phaseNamed("flatten") val mixinPhase = phaseNamed("mixin") diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala new file mode 100644 index 000000000000..e5b4c4a6c21f --- /dev/null +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala @@ -0,0 +1,130 @@ +/* NSC -- new Scala compiler + * Copyright 2005-2014 LAMP/EPFL + * @author Martin Odersky + */ + +package scala.tools.nsc.backend.jvm + +import scala.tools.nsc.Global +import PartialFunction._ + +/** + * This trait contains code shared between GenBCode and GenASM that depends on types defined in + * the compiler cake (Global). + */ +final class BCodeAsmCommon[G <: Global](val global: G) { + import global._ + + /** + * True if `classSym` is an anonymous class or a local class. I.e., false if `classSym` is a + * member class. This method is used to decide if we should emit an EnclosingMethod attribute. + * It is also used to decide whether the "owner" field in the InnerClass attribute should be + * null. + */ + def isAnonymousOrLocalClass(classSym: Symbol): Boolean = { + def isDelambdafyLambdaClass(classSym: Symbol): Boolean = { + classSym.isAnonymousFunction && (settings.Ydelambdafy.value == "method") + } + + assert(classSym.isClass, s"not a class: $classSym") + + !isDelambdafyLambdaClass(classSym) && + (classSym.isAnonymousClass || !classSym.originalOwner.isClass) + } + + /** + * Returns the enclosing method for non-member classes. In the following example + * + * class A { + * def f = { + * class B { + * class C + * } + * } + * } + * + * the method returns Some(f) for B, but None for C, because C is a member class. For non-member + * classes that are not enclosed by a method, it returns None: + * + * class A { + * { class B } + * } + * + * In this case, for B, we return None. + * + * The EnclosingMethod attribute needs to be added to non-member classes (see doc in BTypes). + * This is a source-level property, so we need to use the originalOwner chain to reconstruct it. + */ + private def enclosingMethodForEnclosingMethodAttribute(classSym: Symbol): Option[Symbol] = { + assert(classSym.isClass, classSym) + def enclosingMethod(sym: Symbol): Option[Symbol] = { + if (sym.isClass || sym == NoSymbol) None + else if (sym.isMethod) Some(sym) + else enclosingMethod(sym.originalOwner) + } + enclosingMethod(classSym.originalOwner) + } + + /** + * The enclosing class for emitting the EnclosingMethod attribute. Since this is a source-level + * property, this method looks at the originalOwner chain. See doc in BTypes. + */ + private def enclosingClassForEnclosingMethodAttribute(classSym: Symbol): Symbol = { + assert(classSym.isClass, classSym) + def enclosingClass(sym: Symbol): Symbol = { + if (sym.isClass) sym + else enclosingClass(sym.originalOwner) + } + enclosingClass(classSym.originalOwner) + } + + final case class EnclosingMethodEntry(owner: String, name: String, methodDescriptor: String) + + /** + * If data for emitting an EnclosingMethod attribute. None if `classSym` is a member class (not + * an anonymous or local class). See doc in BTypes. + * + * The class is parametrized by two functions to obtain a bytecode class descriptor for a class + * symbol, and to obtain a method signature descriptor fro a method symbol. These function depend + * on the implementation of GenASM / GenBCode, so they need to be passed in. + */ + def enclosingMethodAttribute(classSym: Symbol, classDesc: Symbol => String, methodDesc: Symbol => String): Option[EnclosingMethodEntry] = { + if (isAnonymousOrLocalClass(classSym)) { + val methodOpt = enclosingMethodForEnclosingMethodAttribute(classSym) + debuglog(s"enclosing method for $classSym is $methodOpt (in ${methodOpt.map(_.enclClass)})") + Some(EnclosingMethodEntry( + classDesc(enclosingClassForEnclosingMethodAttribute(classSym)), + methodOpt.map(_.javaSimpleName.toString).orNull, + methodOpt.map(methodDesc).orNull)) + } else { + None + } + } + + /** + * This is basically a re-implementation of sym.isStaticOwner, but using the originalOwner chain. + * + * The problem is that we are interested in a source-level property. Various phases changed the + * symbol's properties in the meantime, mostly lambdalift modified (destructively) the owner. + * Therefore, `sym.isStatic` is not what we want. For example, in + * object T { def f { object U } } + * the owner of U is T, so UModuleClass.isStatic is true. Phase travel does not help here. + */ + def isOriginallyStaticOwner(sym: Symbol): Boolean = { + sym.isPackageClass || sym.isModuleClass && isOriginallyStaticOwner(sym.originalOwner) + } + + /** + * The member classes of a class symbol. Note that the result of this method depends on the + * current phase, for example, after lambdalift, all local classes become member of the enclosing + * class. + */ + def memberClassesOf(classSymbol: Symbol): List[Symbol] = classSymbol.info.decls.collect({ + case sym if sym.isClass => + sym + case sym if sym.isModule => + val r = exitingPickler(sym.moduleClass) + assert(r != NoSymbol, sym.fullLocationString) + r + })(collection.breakOut) +} diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index 2e629485a0a6..397171049fa0 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -23,8 +23,8 @@ import scala.tools.asm abstract class BCodeBodyBuilder extends BCodeSkelBuilder { import global._ import definitions._ - import bCodeICodeCommon._ import bTypes._ + import bCodeICodeCommon._ import coreBTypes._ /* diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala index 18a9bad1b7d3..aed3654b2ce9 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala @@ -789,55 +789,6 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters { new java.lang.Long(id) ).visitEnd() } - - /* - * @param owner internal name of the enclosing class of the class. - * - * @param name the name of the method that contains the class. - - * @param methodType the method that contains the class. - */ - case class EnclMethodEntry(owner: String, name: String, methodType: BType) - - /* - * @return null if the current class is not internal to a method - * - * Quoting from JVMS 4.7.7 The EnclosingMethod Attribute - * A class must have an EnclosingMethod attribute if and only if it is a local class or an anonymous class. - * A class may have no more than one EnclosingMethod attribute. - * - * must-single-thread - */ - def getEnclosingMethodAttribute(clazz: Symbol): EnclMethodEntry = { // JVMS 4.7.7 - - def newEEE(eClass: Symbol, m: Symbol) = { - EnclMethodEntry( - internalName(eClass), - m.javaSimpleName.toString, - asmMethodType(m) - ) - } - - var res: EnclMethodEntry = null - val sym = clazz.originalEnclosingMethod - if (sym.isMethod) { - debuglog(s"enclosing method for $clazz is $sym (in ${sym.enclClass})") - res = newEEE(sym.enclClass, sym) - } else if (clazz.isAnonymousClass) { - val enclClass = clazz.rawowner - assert(enclClass.isClass, enclClass) - val sym = enclClass.primaryConstructor - if (sym == NoSymbol) { - log(s"Ran out of room looking for an enclosing method for $clazz: no constructor here: $enclClass.") - } else { - debuglog(s"enclosing method for $clazz is $sym (in $enclClass)") - res = newEEE(enclClass, sym) - } - } - - res - } - } // end of trait BCClassGen /* basic functionality for class file building of plain, mirror, and beaninfo classes. */ diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala index 5d187168dbf5..d58368b19d68 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala @@ -19,8 +19,6 @@ import scala.collection.mutable * */ abstract class BCodeIdiomatic extends SubComponent { - protected val bCodeICodeCommon: BCodeICodeCommon[global.type] = new BCodeICodeCommon(global) - val bTypes = new BTypesFromSymbols[global.type](global) import global._ diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala index 3f3c0d062099..4592031a31a6 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala @@ -27,6 +27,7 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { import global._ import bTypes._ import coreBTypes._ + import bCodeAsmCommon._ /* * There's a dedicated PlainClassBuilder for each CompilationUnit, @@ -153,10 +154,10 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { cnode.visitSource(cunit.source.toString, null /* SourceDebugExtension */) } - val enclM = getEnclosingMethodAttribute(claszSymbol) - if (enclM != null) { - val EnclMethodEntry(className, methodName, methodType) = enclM - cnode.visitOuterClass(className, methodName, methodType.descriptor) + enclosingMethodAttribute(claszSymbol, internalName, asmMethodType(_).descriptor) match { + case Some(EnclosingMethodEntry(className, methodName, methodDescriptor)) => + cnode.visitOuterClass(className, methodName, methodDescriptor) + case _ => () } val ssa = getAnnotPickle(thisName, claszSymbol) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala index 389dbe43ebfe..7bf61b4f513a 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala @@ -403,9 +403,11 @@ abstract class BTypes { * Fields in the InnerClass entries: * - inner class: the (nested) class C we are talking about * - outer class: the class of which C is a member. Has to be null for non-members, i.e. for - * local and anonymous classes. + * local and anonymous classes. NOTE: this co-incides with the presence of an + * EnclosingMethod attribute (see below) * - inner name: A string with the simple name of the inner class. Null for anonymous classes. - * - flags: access property flags, details in JVMS, table in 4.7.6. + * - flags: access property flags, details in JVMS, table in 4.7.6. Static flag: see + * discussion below. * * * Note 1: when a nested class is present in the InnerClass attribute, all of its enclosing @@ -446,6 +448,13 @@ abstract class BTypes { * JVMS 4.7.7: the attribute must be present "if and only if it represents a local class * or an anonymous class" (i.e. not for member classes). * + * The attribute is mis-named, it should be called "EnclosingClass". It has to be defined for all + * local and anonymous classes, no matter if there is an enclosing method or not. Accordingly, the + * "class" field (see below) must be always defined, while the "method" field may be null. + * + * NOTE: When a EnclosingMethod attribute is requried (local and anonymous classes), the "outer" + * field in the InnerClass table must be null. + * * Fields: * - class: the enclosing class * - method: the enclosing method (or constructor). Null if the class is not enclosed by a @@ -456,9 +465,8 @@ abstract class BTypes { * Note: the field is required for anonymous classes defined within local variable * initializers (within a method), Java example below (**). * - * Currently, the Scala compiler sets "method" to the class constructor for classes - * defined in initializer blocks or field initializers. This is probably OK, since the - * Scala compiler desugars these statements into to the primary constructor. + * For local and anonymous classes in initializer blocks or field initializers, and + * class-level anonymous classes, the scala compiler sets the "method" field to null. * * * (*) @@ -520,30 +528,37 @@ abstract class BTypes { * STATIC flag * ----------- * - * Java: static nested classes have the "static" flag in the InnerClass attribute. This is not the - * case for local classes defined within a static method, even though such classes, as they are - * defined in a static context, don't take an "outer" instance. - * Non-static nested classes (inner classes, including local classes defined in a non-static - * method) take an "outer" instance on construction. + * Java: static member classes have the static flag in the InnerClass attribute, for example B in + * class A { static class B { } } + * + * The spec is not very clear about when the static flag should be emitted. It says: "Marked or + * implicitly static in source." + * + * The presence of the static flag does NOT coincide with the absence of an "outer" field in the + * class. The java compiler never puts the static flag for local classes, even if they don't have + * an outer pointer: + * + * class A { + * void f() { class B {} } + * static void g() { calss C {} } + * } + * + * B has an outer pointer, C doesn't. Both B and C are NOT marked static in the InnerClass table. + * + * It seems sane to follow the same principle in the Scala compiler. So: * - * Scala: Explicitouter adds an "outer" parameter to nested classes, except for classes defined - * in a static context, i.e. when all outer classes are module classes. * package p * object O1 { - * class C1 // static - * object O2 { + * class C1 // static inner class + * object O2 { // static inner module * def f = { - * class C2 { // static - * class C3 // non-static, needs outer + * class C2 { // non-static inner class, even though there's no outer pointer + * class C3 // non-static, has an outer pointer * } * } * } * } * - * Int the InnerClass attribute, the `static` flag is added for all classes defined in a static - * context, i.e. also for C2. This is different than in Java. - * - * * Mirror Classes * -------------- * @@ -799,7 +814,12 @@ abstract class BTypes { * to the InnerClass table, enclosing nested classes are also added. * @param outerName The outerName field in the InnerClass entry, may be None. * @param innerName The innerName field, may be None. - * @param isStaticNestedClass True if this is a static nested class (not inner class). + * @param isStaticNestedClass True if this is a static nested class (not inner class) (*) + * + * (*) Note that the STATIC flag in ClassInfo.flags, obtained through javaFlags(classSym), is not + * correct for the InnerClass entry, see javaFlags. The static flag in the InnerClass describes + * a source-level propety: if the class is in a static context (does not have an outer pointer). + * This is checked when building the NestedInfo. */ case class NestedInfo(enclosingClass: ClassBType, outerName: Option[String], diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala index da3244ba2307..0e2f938602e4 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala @@ -24,6 +24,10 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes { import global._ import definitions._ + val bCodeICodeCommon: BCodeICodeCommon[global.type] = new BCodeICodeCommon(global) + val bCodeAsmCommon: BCodeAsmCommon[global.type] = new BCodeAsmCommon(global) + import bCodeAsmCommon._ + // Why the proxy, see documentation of class [[CoreBTypes]]. val coreBTypes = new CoreBTypesProxy[this.type](this) import coreBTypes._ @@ -114,45 +118,63 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes { val flags = javaFlags(classSym) - def classOrModuleClass(sym: Symbol): Symbol = { - if (sym.isClass) sym - else if (sym.isModule) sym.moduleClass - else NoSymbol - } - - /* The InnerClass table must contain all nested classes. Local or anonymous classes (not - * members) are referenced from the emitted code of the class, so they are in innerClassBuffer. + /* The InnerClass table of a class C must contain all nested classes of C, even if they are only + * declared but not otherwise referenced in C (from the bytecode or a method / field signature). + * We collect them here. * - * TODO @lry check the above. For example: class C { def foo = { class D; 0 } }, is D added? + * Nested classes that are also referenced in C will be added to the innerClassBufferASM during + * code generation, but those duplicates will be eliminated when emitting the InnerClass + * attribute. * - * For member classes however, there might be no reference at all in the code of the class. - * The JMV spec still requires those classes to be added to the InnerClass table, so we collect - * them here. + * Why doe we need to collect classes into innerClassBufferASM at all? To collect references to + * nested classes, but NOT nested in C, that are used within C. */ - val memberClassSymbols = exitingErasure { - // time travel to a time before lambdalift (which lifts local classes up to the class, making them members) - for (sym <- List(classSym, classSym.linkedClassOfClass); - memberClass <- sym.info.decls.map(classOrModuleClass) if memberClass.isClass) - yield memberClass + val nestedClassSymbols = { + // The lambdalift phase lifts all nested classes to the enclosing class, so if we collect + // member classes right after lambdalift, we obtain all nested classes, including local and + // anonymous ones. + val nestedClasses = exitingPhase(currentRun.lambdaliftPhase)(memberClassesOf(classSym)) + + // If this is a top-level class, and it has a companion object, the member classes of the + // companion are added as members of the class. For example: + // class C { } + // object C { + // class D + // def f = { class E } + // } + // The class D is added as a member of class C. The reason is that the InnerClass attribute + // for D will containt class "C" and NOT the module class "C$" as the outer class of D. + // This is done by buildNestedInfo, the reason is Java compatibility, see comment in BTypes. + // For consistency, the InnerClass entry for D needs to be present in C - to Java it looks + // like D is a member of C, not C$. + val linkedClass = exitingPickler(classSym.linkedClassOfClass) // linkedCoC does not work properly in late phases + val companionModuleMembers = { + // phase travel to exitingPickler: this makes sure that memberClassesOf only sees member classes, + // not local classes of the companion module (E in the exmaple) that were lifted by lambdalift. + if (isTopLevelModuleClass(linkedClass)) exitingPickler(memberClassesOf(linkedClass)) + else Nil + } + + nestedClasses ++ companionModuleMembers } /** * For nested java classes, the scala compiler creates both a class and a module (and therefore - * a module class) symbol. For example, in `class A { class B {} }`, the memberClassSymbols + * a module class) symbol. For example, in `class A { class B {} }`, the nestedClassSymbols * for A contain both the class B and the module class B. * Here we get rid of the module class B, making sure that the class B is present. */ - val memberClassSymbolsNoJavaModuleClasses = memberClassSymbols.filter(s => { + val nestedClassSymbolsNoJavaModuleClasses = nestedClassSymbols.filter(s => { if (s.isJavaDefined && s.isModuleClass) { - // We could also search in memberClassSymbols for s.linkedClassOfClass, but sometimes that + // We could also search in nestedClassSymbols for s.linkedClassOfClass, but sometimes that // returns NoSymbol, so it doesn't work. - val nb = memberClassSymbols.count(mc => mc.name == s.name && mc.owner == s.owner) - assert(nb == 2, s"Java member module without member class: $s - $memberClassSymbols") + val nb = nestedClassSymbols.count(mc => mc.name == s.name && mc.owner == s.owner) + assert(nb == 2, s"Java member module without member class: $s - $nestedClassSymbols") false } else true }) - val memberClasses = memberClassSymbolsNoJavaModuleClasses.map(classBTypeFromSymbol) + val memberClasses = nestedClassSymbolsNoJavaModuleClasses.map(classBTypeFromSymbol) val nestedInfo = buildNestedInfo(classSym) @@ -207,10 +229,8 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes { val isNested = !innerClassSym.rawowner.isPackageClass if (!isNested) None else { - // Phase travel to a time where the owner chain is in its original form. Example: - // object T { def f { class C } } - // C is an inner class (not a static nested class), see InnerClass summary in BTypes. - val isStaticNestedClass = enteringPickler(innerClassSym.isStatic) + // See comment in BTypes, when is a class marked static in the InnerClass table. + val isStaticNestedClass = isOriginallyStaticOwner(innerClassSym.originalOwner) // After lambdalift (which is where we are), the rawowoner field contains the enclosing class. val enclosingClassSym = { @@ -220,15 +240,20 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes { // nested class, the symbol for D is nested in the module class C (not in the class C). // For the InnerClass attribute, we use the class symbol C, which represents the situation // in the source code. - assert(innerClassSym.isStatic, innerClassSym.rawowner) - innerClassSym.rawowner.linkedClassOfClass + + // Cannot use innerClassSym.isStatic: this method looks at the owner, which is a package + // at this pahse (after lambdalift, flatten). + assert(isOriginallyStaticOwner(innerClassSym.originalOwner), innerClassSym.originalOwner) + + // phase travel for linkedCoC - does not always work in late phases + exitingPickler(innerClassSym.rawowner.linkedClassOfClass) } else innerClassSym.rawowner } val enclosingClass: ClassBType = classBTypeFromSymbol(enclosingClassSym) val outerName: Option[String] = { - if (innerClassSym.originalEnclosingMethod != NoSymbol) { + if (isAnonymousOrLocalClass(innerClassSym)) { None } else { val outerName = innerClassSym.rawowner.javaBinaryName @@ -266,23 +291,10 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes { * for such objects will get a MODULE$ flag and a corresponding static initializer. */ final def isStaticModuleClass(sym: Symbol): Boolean = { - /* The implementation of this method is tricky because it is a source-level property. Various - * phases changed the symbol's properties in the meantime. - * - * (1) Phase travel to to pickler is required to exclude implementation classes; they have the + /* (1) Phase travel to to pickler is required to exclude implementation classes; they have the * lateMODULEs after mixin, so isModuleClass would be true. - * - * (2) We cannot use `sym.isStatic` because lambdalift modified (destructively) the owner. For - * example, in - * object T { def f { object U } } - * the owner of U is T, so UModuleClass.isStatic is true. Phase travel does not help here. - * So we basically re-implement `sym.isStaticOwner`, but using the original owner chain. + * (2) isStaticModuleClass is a source-level property. See comment on isOriginallyStaticOwner. */ - - def isOriginallyStaticOwner(sym: Symbol): Boolean = { - sym.isPackageClass || sym.isModuleClass && isOriginallyStaticOwner(sym.originalOwner) - } - exitingPickler { // (1) sym.isModuleClass && isOriginallyStaticOwner(sym.originalOwner) // (2) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala index 2392033760b4..2593903b9de6 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala @@ -26,6 +26,9 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { import icodes.opcodes._ import definitions._ + val bCodeAsmCommon: BCodeAsmCommon[global.type] = new BCodeAsmCommon(global) + import bCodeAsmCommon._ + // Strangely I can't find this in the asm code // 255, but reserving 1 for "this" final val MaximumJvmParameters = 254 @@ -621,7 +624,7 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { * That means non-member classes (anonymous). See Section 4.7.5 in the JVMS. */ def outerName(innerSym: Symbol): String = { - if (innerSym.originalEnclosingMethod != NoSymbol) + if (isAnonymousOrLocalClass(innerSym)) null else { val outerName = javaName(innerSym.rawowner) @@ -636,13 +639,16 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { else innerSym.rawname + innerSym.moduleSuffix - // add inner classes which might not have been referenced yet - // TODO @lry according to the spec, all nested classes should be added, also local and - // anonymous. This seems to add only member classes - or not? it's exitingErasure, so maybe - // local / anonymous classes have been lifted by lambdalift. are they in the "decls" though? - exitingErasure { - for (sym <- List(csym, csym.linkedClassOfClass); m <- sym.info.decls.map(innerClassSymbolFor) if m.isClass) - innerClassBuffer += m + // This collects all inner classes of csym, including local and anonymous: lambdalift makes + // them members of their enclosing class. + innerClassBuffer ++= exitingPhase(currentRun.lambdaliftPhase)(memberClassesOf(csym)) + + // Add members of the companion object (if top-level). why, see comment in BTypes.scala. + val linkedClass = exitingPickler(csym.linkedClassOfClass) // linkedCoC does not work properly in late phases + if (isTopLevelModule(linkedClass)) { + // phase travel to exitingPickler: this makes sure that memberClassesOf only sees member classes, + // not local classes that were lifted by lambdalift. + innerClassBuffer ++= exitingPickler(memberClassesOf(linkedClass)) } val allInners: List[Symbol] = innerClassBuffer.toList filterNot deadCode.elidedClosures @@ -656,7 +662,8 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { // sort them so inner classes succeed their enclosing class to satisfy the Eclipse Java compiler for (innerSym <- allInners sortBy (_.name.length)) { // TODO why not sortBy (_.name.toString()) ?? val flagsWithFinal: Int = mkFlags( - if (innerSym.rawowner.hasModuleFlag) asm.Opcodes.ACC_STATIC else 0, + // See comment in BTypes, when is a class marked static in the InnerClass table. + if (isOriginallyStaticOwner(innerSym.originalOwner)) asm.Opcodes.ACC_STATIC else 0, javaFlags(innerSym), if(isDeprecated(innerSym)) asm.Opcodes.ACC_DEPRECATED else 0 // ASM pseudo-access flag ) & (INNER_CLASSES_FLAGS | asm.Opcodes.ACC_DEPRECATED) @@ -1222,10 +1229,10 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { null /* SourceDebugExtension */) } - val enclM = getEnclosingMethodAttribute() - if(enclM != null) { - val EnclMethodEntry(className, methodName, methodType) = enclM - jclass.visitOuterClass(className, methodName, methodType.getDescriptor) + enclosingMethodAttribute(clasz.symbol, javaName, javaType(_).getDescriptor) match { + case Some(EnclosingMethodEntry(className, methodName, methodDescriptor)) => + jclass.visitOuterClass(className, methodName, methodDescriptor) + case _ => () } // typestate: entering mode with valid call sequences: @@ -1286,45 +1293,6 @@ abstract class GenASM extends SubComponent with BytecodeWriters with GenJVMASM { writeIfNotTooBig("" + c.symbol.name, thisName, jclass, c.symbol) } - /** - * @param owner internal name of the enclosing class of the class. - * - * @param name the name of the method that contains the class. - - * @param methodType the method that contains the class. - */ - case class EnclMethodEntry(owner: String, name: String, methodType: asm.Type) - - /** - * @return null if the current class is not internal to a method - * - * Quoting from JVMS 4.7.7 The EnclosingMethod Attribute - * A class must have an EnclosingMethod attribute if and only if it is a local class or an anonymous class. - * A class may have no more than one EnclosingMethod attribute. - * - */ - private def getEnclosingMethodAttribute(): EnclMethodEntry = { // JVMS 4.7.7 - var res: EnclMethodEntry = null - val clazz = clasz.symbol - val sym = clazz.originalEnclosingMethod - if (sym.isMethod) { - debuglog("enclosing method for %s is %s (in %s)".format(clazz, sym, sym.enclClass)) - res = EnclMethodEntry(javaName(sym.enclClass), javaName(sym), javaType(sym)) - } else if (clazz.isAnonymousClass) { - val enclClass = clazz.rawowner - assert(enclClass.isClass, enclClass) - val sym = enclClass.primaryConstructor - if (sym == NoSymbol) { - log("Ran out of room looking for an enclosing method for %s: no constructor here.".format(enclClass)) - } else { - debuglog("enclosing method for %s is %s (in %s)".format(clazz, sym, enclClass)) - res = EnclMethodEntry(javaName(enclClass), javaName(sym), javaType(sym)) - } - } - - res - } - def genField(f: IField) { debuglog("Adding field: " + f.symbol.fullName) diff --git a/src/compiler/scala/tools/nsc/transform/Erasure.scala b/src/compiler/scala/tools/nsc/transform/Erasure.scala index ec4deb6be03e..d5ffa1fa5ba7 100644 --- a/src/compiler/scala/tools/nsc/transform/Erasure.scala +++ b/src/compiler/scala/tools/nsc/transform/Erasure.scala @@ -468,8 +468,12 @@ abstract class Erasure extends AddInterfaces if (!bridgeNeeded) return - val newFlags = (member.flags | BRIDGE | ARTIFACT) & ~(ACCESSOR | DEFERRED | LAZY | lateDEFERRED) - val bridge = other.cloneSymbolImpl(root, newFlags) setPos root.pos + var newFlags = (member.flags | BRIDGE | ARTIFACT) & ~(ACCESSOR | DEFERRED | LAZY | lateDEFERRED) + // If `member` is a ModuleSymbol, the bridge should not also be a ModuleSymbol. Otherwise we + // end up with two module symbols with the same name in the same scope, which is surprising + // when implementing later phases. + if (member.isModule) newFlags = (newFlags | METHOD) & ~(MODULE | lateMETHOD | STABLE) + val bridge = other.cloneSymbolImpl(root, newFlags) setPos root.pos debuglog("generating bridge from %s (%s): %s to %s: %s".format( other, flagsToString(newFlags), diff --git a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala index f85d8222f06f..d69c9d9a65da 100644 --- a/src/compiler/scala/tools/nsc/transform/LambdaLift.scala +++ b/src/compiler/scala/tools/nsc/transform/LambdaLift.scala @@ -449,6 +449,8 @@ abstract class LambdaLift extends InfoTransform { if (sym.isClass) sym.owner = sym.owner.toInterface if (sym.isMethod) sym setFlag LIFTED liftedDefs(sym.owner) ::= tree + // TODO: this modifies the ClassInfotype of the enclosing class, which is associated with another phase (explicitouter). + // This breaks type history: in a phase travel to before lambda lift, the ClassInfoType will contain lifted classes. sym.owner.info.decls enterUnique sym debuglog("lifted: " + sym + " from " + oldOwner + " to " + sym.owner) EmptyTree diff --git a/src/interactive/scala/tools/nsc/interactive/Global.scala b/src/interactive/scala/tools/nsc/interactive/Global.scala index 95027a26b120..174254d52369 100644 --- a/src/interactive/scala/tools/nsc/interactive/Global.scala +++ b/src/interactive/scala/tools/nsc/interactive/Global.scala @@ -142,8 +142,6 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "") // don't keep the original owner in presentation compiler runs // (the map will grow indefinitely, and the only use case is the backend) override protected def saveOriginalOwner(sym: Symbol) { } - override protected def originalEnclosingMethod(sym: Symbol) = - abort("originalOwner is not kept in presentation compiler runs.") override def forInteractive = true override protected def synchronizeNames = true diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala index b6cce4524b48..d132b76f3028 100644 --- a/src/reflect/scala/reflect/internal/Symbols.scala +++ b/src/reflect/scala/reflect/internal/Symbols.scala @@ -74,15 +74,6 @@ trait Symbols extends api.Symbols { self: SymbolTable => } } - protected def originalEnclosingMethod(sym: Symbol): Symbol = { - if (sym.isMethod || sym == NoSymbol) sym - else { - val owner = sym.originalOwner - if (sym.isLocalDummy) owner.enclClass.primaryConstructor - else originalEnclosingMethod(owner) - } - } - def symbolOf[T: WeakTypeTag]: TypeSymbol = weakTypeOf[T].typeSymbolDirect.asType abstract class SymbolContextApiImpl extends SymbolApi { @@ -2122,16 +2113,6 @@ trait Symbols extends api.Symbols { self: SymbolTable => * is not one. */ def enclosingPackage: Symbol = enclosingPackageClass.companionModule - /** Return the original enclosing method of this symbol. It should return - * the same thing as enclMethod when called before lambda lift, - * but it preserves the original nesting when called afterwards. - * - * @note This method is NOT available in the presentation compiler run. The - * originalOwner map is not populated for memory considerations (the symbol - * may hang on to lazy types and in turn to whole (outdated) compilation units. - */ - def originalEnclosingMethod: Symbol = Symbols.this.originalEnclosingMethod(this) - /** The method or class which logically encloses the current symbol. * If the symbol is defined in the initialization part of a template * this is the template's primary constructor, otherwise it is @@ -3532,7 +3513,6 @@ trait Symbols extends api.Symbols { self: SymbolTable => override def rawInfo: Type = NoType override def accessBoundary(base: Symbol): Symbol = enclosingRootClass def cloneSymbolImpl(owner: Symbol, newFlags: Long) = abort("NoSymbol.clone()") - override def originalEnclosingMethod = this } protected def makeNoSymbol: NoSymbol = new NoSymbol diff --git a/src/reflect/scala/reflect/runtime/JavaMirrors.scala b/src/reflect/scala/reflect/runtime/JavaMirrors.scala index 6584d80de363..b7f229b6e586 100644 --- a/src/reflect/scala/reflect/runtime/JavaMirrors.scala +++ b/src/reflect/scala/reflect/runtime/JavaMirrors.scala @@ -807,31 +807,26 @@ private[scala] trait JavaMirrors extends internal.SymbolTable with api.JavaUnive // field containing the cache for structural calls. if (mods.isStatic) module.moduleClass.orElse(clazz) else clazz - /** Methods which need to be treated with care - * because they either are getSimpleName or call getSimpleName: + /** + * Certain method of the Java reflection api cannot be used on classfiles created by Scala. + * See the comment in test/files/jvm/javaReflection/Test.scala. The methods are * * public String getSimpleName() * public boolean isAnonymousClass() * public boolean isLocalClass() * public String getCanonicalName() - * - * A typical manifestation: - * - * // java.lang.Error: sOwner(class Test$A$1) has failed - * // Caused by: java.lang.InternalError: Malformed class name - * // at java.lang.Class.getSimpleName(Class.java:1133) - * // at java.lang.Class.isAnonymousClass(Class.java:1188) - * // at java.lang.Class.isLocalClass(Class.java:1199) - * // (see t5256c.scala for more details) + * public boolean isSynthetic() * * TODO - find all such calls and wrap them. * TODO - create mechanism to avoid the recurrence of unwrapped calls. */ implicit class RichClass(jclazz: jClass[_]) { - // `jclazz.isLocalClass` doesn't work because of problems with `getSimpleName` - // hence we have to approximate by removing the `isAnonymousClass` check -// def isLocalClass0: Boolean = jclazz.isLocalClass - def isLocalClass0: Boolean = jclazz.getEnclosingMethod != null || jclazz.getEnclosingConstructor != null + // As explained in the javaReflection test, Class.isLocalClass is true for all non-member + // nested classes in Scala. This is fine per se, however the implementation may throw an + // InternalError. We therefore re-implement it here. + // TODO: this method should be renamed to `isLocalOrAnonymousClass`. + // due to bin compat that's only possible in 2.12, we cannot introduce a new alias in 2.11. + def isLocalClass0: Boolean = jclazz.getEnclosingClass != null && !jclazz.isMemberClass } /** diff --git a/test/files/jvm/innerClassAttribute.check b/test/files/jvm/innerClassAttribute.check new file mode 100644 index 000000000000..20518aa49e4b --- /dev/null +++ b/test/files/jvm/innerClassAttribute.check @@ -0,0 +1,54 @@ +#partest !-Ydelambdafy:method +-- A4 -- +A4$$anonfun$f$1 / null / null / 17 +A4$$anonfun$f$1 / null / null / 17 +A4 / f / (Lscala/collection/immutable/List;)Lscala/collection/immutable/List; +-- A19 -- +A19$$anonfun$1 / null / null / 17 +A19$$anonfun$2 / null / null / 17 +A19$$anonfun$3 / null / null / 17 +A19$$anonfun$1 / null / null / 17 +A19$$anonfun$2 / null / null / 17 +A19$$anonfun$3 / null / null / 17 +A19 / null / null +A19 / null / null +A19 / null / null +-- A20 -- +A20$$anonfun$4 / null / null / 17 +fun1: attribute for itself and the two child closures `() => ()` and `() => () => 1` +A20$$anonfun$4 / null / null / 17 +A20$$anonfun$4$$anonfun$apply$1 / null / null / 17 +A20$$anonfun$4$$anonfun$apply$3 / null / null / 17 +fun2 () => (): itself and the outer closure +A20$$anonfun$4 / null / null / 17 +A20$$anonfun$4$$anonfun$apply$1 / null / null / 17 +fun3 () => () => (): itself, the outer closure and its child closure +A20$$anonfun$4 / null / null / 17 +A20$$anonfun$4$$anonfun$apply$3 / null / null / 17 +A20$$anonfun$4$$anonfun$apply$3$$anonfun$apply$2 / null / null / 17 +fun4: () => 1: itself and the two outer closures +A20$$anonfun$4 / null / null / 17 +A20$$anonfun$4$$anonfun$apply$3 / null / null / 17 +A20$$anonfun$4$$anonfun$apply$3$$anonfun$apply$2 / null / null / 17 +enclosing: nested closures have the apply method of the outer closure +A20 / null / null +A20$$anonfun$4 / apply / ()Lscala/Function0; +A20$$anonfun$4 / apply / ()Lscala/Function0; +A20$$anonfun$4$$anonfun$apply$3 / apply / ()Lscala/Function0; +#partest -Ydelambdafy:method +-- A4 -- +null / null / null +-- A19 -- +null / null / null +null / null / null +null / null / null +-- A20 -- +fun1: attribute for itself and the two child closures `() => ()` and `() => () => 1` +fun2 () => (): itself and the outer closure +fun3 () => () => (): itself, the outer closure and its child closure +fun4: () => 1: itself and the two outer closures +enclosing: nested closures have the apply method of the outer closure +null / null / null +null / null / null +null / null / null +null / null / null diff --git a/test/files/jvm/innerClassAttribute/Classes_1.scala b/test/files/jvm/innerClassAttribute/Classes_1.scala index 0875d9160c91..9c3ea7f01339 100644 --- a/test/files/jvm/innerClassAttribute/Classes_1.scala +++ b/test/files/jvm/innerClassAttribute/Classes_1.scala @@ -74,7 +74,7 @@ class A14 { object A15 { def f = { - class B { // static (does not have an outer pointer) + class B { // non-static, even though it doesn't have an outer pointer class C // non-static } } @@ -90,10 +90,98 @@ class A16 { class V extends A6 new A6 { } } + + new A6 { } } class A17 { object B { - class C // not static, has an outer pointer. + class C // not static, also has an outer pointer. + } +} + +class A18 { + def f = { + def g = { + class A + new A6 { } + val y = { + if ((new Object).hashCode() == 1) {class B {} ; new B} else 2 + if ((new Object).hashCode() == 1) new A6 { } else "haifish" + } + } + } +} + +class A19 { + ((x: Int) => x + 3) + + val x = { + ((x: Int) => x + 1) + } + + { + ((x: Int) => x + 2) + } +} + +class A20 { + () => { + {() => ()} + {() => () => 1} + } +} + +class A21 { + class I1 + def f = { class J1 } +} +object A21 { + class I2 + object I3 { + class J2 // static + } + def g = { class J3 } // non-static + val x = { class J4 } // non-static + { + class J5 // non-static (!) + new J5 + } +} + +class A22 { + class C + object C { + class D // inner class of C$, not of C. Not added to the inner class table of C, only to C$ + } +} + +class A23 { + def f = { + val a = new Java_A_1() + val c = new Java_A_1.C() + val d = new Java_A_1.C.D() + val e = new c.E() + val f = new a.F() + val g = new f.G() + } +} + +trait A24Sym + +trait A24Base { + // trait with concrete members: interface plus (absract) impl class + trait DefinitionsApi { + def Abs: A24Sym + def Conc: A24Sym = new A24Sym { } + } +} + +trait A24 extends A24Base { + class DefinitionsClass extends DefinitionsApi { + // bridge methods are generated for Abs and Conc. there used to be a bug: the bridge symbol was a ModuleSymbol, + // calling companionClass would return NoSymbol. i changed erasure to make the bridge symbol is a MethodSymbol. + object Abs extends A24Sym + override object Conc extends A24Sym } } diff --git a/test/files/jvm/innerClassAttribute/Java_A_1.java b/test/files/jvm/innerClassAttribute/Java_A_1.java new file mode 100644 index 000000000000..3357d05e2bb4 --- /dev/null +++ b/test/files/jvm/innerClassAttribute/Java_A_1.java @@ -0,0 +1,10 @@ +public class Java_A_1 { + public static class C { + public static class D { } + public class E { } + } + + public class F { + public class G { } + } +} diff --git a/test/files/jvm/innerClassAttribute/Test.scala b/test/files/jvm/innerClassAttribute/Test.scala index 6cf60ab92df5..882edbcdd7b7 100644 --- a/test/files/jvm/innerClassAttribute/Test.scala +++ b/test/files/jvm/innerClassAttribute/Test.scala @@ -43,10 +43,30 @@ object Test extends BytecodeTest { assertSame(node.access, flags) } - def assertEnclosingMethod(enclosingMethod: EnclosingMethod, outerClass: String, name: String, descriptor: String) = { - assertSame(enclosingMethod.outerClass, outerClass) - assertSame(enclosingMethod.name, name) - assertSame(enclosingMethod.descriptor, descriptor) + def assertEnclosingMethod(className: String, outerClass: String, name: String, descriptor: String) = { + val encl = enclosingMethod(className) + assertSame(encl.outerClass, outerClass) + assertSame(encl.name, name) + assertSame(encl.descriptor, descriptor) + } + + def assertNoEnclosingMethod(className: String) = { + assertSame(enclosingMethod(className).outerClass, null) + } + + def printInnerClassNodes(className: String) = { + for (n <- innerClassNodes(className)) { + println(s"${n.name} / ${n.outerName} / ${n.innerName} / ${n.access}") + } + } + + def printEnclosingMethod(className: String) = { + val e = enclosingMethod(className) + println(s"${e.outerClass} / ${e.name} / ${e.descriptor}") + } + + def lambdaClass(anonfunName: String, lambdaName: String): String = { + if (classpath.findClass(anonfunName).isDefined) anonfunName else lambdaName } def testA1() = { @@ -78,13 +98,11 @@ object Test extends BytecodeTest { } def testA4() = { - val List(an1) = innerClassNodes("A4") - assertAnonymous(an1, "A4$$anonfun$f$1") - val List(an2) = innerClassNodes("A4$$anonfun$f$1") - assertAnonymous(an2, "A4$$anonfun$f$1") - assertEnclosingMethod( - enclosingMethod("A4$$anonfun$f$1"), - "A4", "f", "(Lscala/collection/immutable/List;)Lscala/collection/immutable/List;") + println("-- A4 --") + printInnerClassNodes("A4") + val fun = lambdaClass("A4$$anonfun$f$1", "A4$lambda$$f$1") + printInnerClassNodes(fun) + printEnclosingMethod(fun) } def testA5() = { @@ -93,7 +111,7 @@ object Test extends BytecodeTest { val List(b2) = innerClassNodes("A5$B$2$") assertLocal(b2, "A5$B$2$", "B$2$") assertEnclosingMethod( - enclosingMethod("A5$B$2$"), + "A5$B$2$", "A5", "f", "()Ljava/lang/Object;") } @@ -136,56 +154,175 @@ object Test extends BytecodeTest { assertLocal(k, "A14$K$1", "K$1") assertEnclosingMethod( - enclosingMethod("A14$K$1"), + "A14$K$1", "A14", "f", "()Ljava/lang/Object;") assertAnonymous(anon, "A14$$anon$1") assertEnclosingMethod( - enclosingMethod("A14$$anon$1"), + "A14$$anon$1", "A14", "g", "()V") } def testA15() = { val List(b) = innerClassNodes("A15") - assertLocal(b, "A15$B$3", "B$3", flags = publicStatic) + assertLocal(b, "A15$B$3", "B$3") val List(_, c) = innerClassNodes("A15$B$3") - // TODO this is a bug in the backend, C should be a member. Instead, its outerClass is null - // assertMember(c, "A15$B$3", "C") - assertLocal(c, "A15$B$3$C", "C") + assertMember(c, "A15$B$3", "C") + + assertEnclosingMethod( + "A15$B$3", + "A15$", "f", "()V") + assertNoEnclosingMethod("A15$B$3$C") } def testA16() = { - val List(anon1, anon2, u, v) = innerClassNodes("A16") - // TODO there's a bug in the backend: anon$2 has outerClass A16, but anonymous classes should have outerClass null - // assertAnonymous(anon1, "A16$$anon$2") - assertMember(anon1, "A16", null, name = Some("A16$$anon$2"), flags = Flags.ACC_PUBLIC | Flags.ACC_FINAL) + val List(anon1, anon2, anon3, u, v) = innerClassNodes("A16") + assertAnonymous(anon1, "A16$$anon$2") assertAnonymous(anon2, "A16$$anon$3") - // TODO this is a bug in the backend, U should not be a member, its outerClass should be null - // assertLocal(u, "A16$U$1", "U$1") - assertMember(u, "A16", "U$1") + assertAnonymous(anon3, "A16$$anon$4") + + assertLocal(u, "A16$U$1", "U$1") assertLocal(v, "A16$V$1", "V$1") assertEnclosingMethod( - enclosingMethod("A16$$anon$2"), - "A16", "", "()V") + "A16$$anon$2", + "A16", null, null) + assertEnclosingMethod( + "A16$$anon$3", + "A16", null, null) + assertEnclosingMethod( + "A16$$anon$4", + "A16", null, null) + assertEnclosingMethod( - enclosingMethod("A16$$anon$3"), - "A16", "", "()V") - // TODO this is a bug, there should be an enclosingMethod attribute in U - // assertEnclosingMethod( - // enclosingMethod("A16$U$1"), - // "A16", "", "()V") + "A16$U$1", + "A16", null, null) assertEnclosingMethod( - enclosingMethod("A16$V$1"), - "A16", "", "()V") + "A16$V$1", + "A16", null, null) } def testA17() = { val List(b, c) = innerClassNodes("A17$B$") assertMember(b, "A17", "B$") - // TODO this is a bug, should not be static. - assertMember(c, "A17$B$", "C", name = Some("A17$B$C"), flags = publicStatic) // (should be) not static, has an outer pointer. + assertMember(c, "A17$B$", "C", name = Some("A17$B$C")) // not static, has an outer pointer. + } + + def testA18() = { + val List(anon1, anon2, a, b) = innerClassNodes("A18") + assertAnonymous(anon1, "A18$$anon$5") + assertAnonymous(anon2, "A18$$anon$6") + + assertLocal(a, "A18$A$1", "A$1") + assertLocal(b, "A18$B$4", "B$4") + + assertEnclosingMethod( + "A18$$anon$5", + "A18", "g$1", "()V") + assertEnclosingMethod( + "A18$$anon$6", + "A18", "g$1", "()V") + + assertEnclosingMethod( + "A18$A$1", + "A18", "g$1", "()V") + assertEnclosingMethod( + "A18$B$4", + "A18", "g$1", "()V") + } + + def testA19() = { + println("-- A19 --") + + printInnerClassNodes("A19") + + val fun1 = lambdaClass("A19$$anonfun$1", "A19$lambda$1") + val fun2 = lambdaClass("A19$$anonfun$2", "A19$lambda$2") + val fun3 = lambdaClass("A19$$anonfun$3", "A19$lambda$3") + + printInnerClassNodes(fun1) + printInnerClassNodes(fun2) + printInnerClassNodes(fun3) + + printEnclosingMethod(fun1) + printEnclosingMethod(fun2) + printEnclosingMethod(fun3) + } + + def testA20() = { + println("-- A20 --") + + printInnerClassNodes("A20") + + val fun1 = lambdaClass("A20$$anonfun$4", "A20$lambda$1") + val fun2 = lambdaClass("A20$$anonfun$4$$anonfun$apply$1", "A20$lambda$$$anonfun$5$1") + val fun3 = lambdaClass("A20$$anonfun$4$$anonfun$apply$3", "A20$lambda$$$anonfun$5$2") + val fun4 = lambdaClass("A20$$anonfun$4$$anonfun$apply$3$$anonfun$apply$2", "A20$lambda$$$anonfun$7$1") + + println("fun1: attribute for itself and the two child closures `() => ()` and `() => () => 1`") + printInnerClassNodes(fun1) + println("fun2 () => (): itself and the outer closure") + printInnerClassNodes(fun2) + println("fun3 () => () => (): itself, the outer closure and its child closure") + printInnerClassNodes(fun3) + println("fun4: () => 1: itself and the two outer closures") + printInnerClassNodes(fun4) + + println("enclosing: nested closures have the apply method of the outer closure") + printEnclosingMethod(fun1) + printEnclosingMethod(fun2) + printEnclosingMethod(fun3) + printEnclosingMethod(fun4) + } + + def testA21() = { + val List(i1c, i2c, i3c, j1) = innerClassNodes("A21") + assertMember(i1c, "A21", "I1") + assertMember(i2c, "A21", "I2", flags = publicStatic) + assertMember(i3c, "A21", "I3$", flags = publicStatic) + assertLocal(j1, "A21$J1$1", "J1$1") + + val List(i2m, i3m, j3, j4, j5) = innerClassNodes("A21$") + assertMember(i2m, "A21", "I2", flags = publicStatic) + assertMember(i3m, "A21", "I3$", flags = publicStatic) + assertLocal(j3, "A21$J3$1", "J3$1") + assertLocal(j4, "A21$J4$1", "J4$1") + assertLocal(j5, "A21$J5$1", "J5$1") // non-static! + + val List(i3x, j2x) = innerClassNodes("A21$I3$J2") + assertMember(j2x, "A21$I3$", "J2", name = Some("A21$I3$J2"), flags = publicStatic) + + assertNoEnclosingMethod("A21$I3$J2") + assertEnclosingMethod("A21$J3$1", "A21$", "g", "()V") + assertEnclosingMethod("A21$J4$1", "A21$", null, null) + assertEnclosingMethod("A21$J5$1", "A21$", null, null) + } + + def testA22() = { + val List(cc) = innerClassNodes("A22$C") + assertMember(cc, "A22", "C") + val List(cm, d) = innerClassNodes("A22$C$") + assertMember(cm, "A22", "C$") + assertMember(d, "A22$C$", "D", name = Some("A22$C$D")) + } + + def testA23() { + val List(c, d, e, f, g) = innerClassNodes("A23") + assertMember(c, "Java_A_1", "C", flags = publicStatic) + assertMember(d, "Java_A_1$C", "D", flags = publicStatic) + assertMember(e, "Java_A_1$C", "E") + assertMember(f, "Java_A_1", "F") + assertMember(g, "Java_A_1$F", "G") + } + + def testA24() { + val List(defsCls, abs, conc, defsApi, defsApiImpl) = innerClassNodes("A24$DefinitionsClass") + assertMember(defsCls, "A24", "DefinitionsClass") + assertMember(abs, "A24$DefinitionsClass", "Abs$") + assertMember(conc, "A24$DefinitionsClass", "Conc$") + assertMember(defsApi, "A24Base", "DefinitionsApi", flags = publicAbstractInterface) + assertMember(defsApiImpl, "A24Base", "DefinitionsApi$class", flags = Flags.ACC_PUBLIC | Flags.ACC_ABSTRACT) } def show(): Unit = { @@ -204,5 +341,12 @@ object Test extends BytecodeTest { testA15() testA16() testA17() + testA18() + testA19() + testA20() + testA21() + testA22() + testA23() + testA24() } } diff --git a/test/files/jvm/javaReflection.check b/test/files/jvm/javaReflection.check new file mode 100644 index 000000000000..aeb894f7417c --- /dev/null +++ b/test/files/jvm/javaReflection.check @@ -0,0 +1,259 @@ +#partest !-Ydelambdafy:method +A$$anonfun$$lessinit$greater$1 / null (canon) / $anonfun$$lessinit$greater$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / public A(int) (constr) / null (meth) +- properties : true (local) / false (member) +A$$anonfun$$lessinit$greater$1$$anonfun$apply$1 / null (canon) / $anonfun$apply$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A$$anonfun$$lessinit$greater$1 (cls) / null (constr) / public final scala.Function0 A$$anonfun$$lessinit$greater$1.apply() (meth) +- properties : true (local) / false (member) +A$$anonfun$2 / null (canon) / $anonfun$2 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$$anonfun$3 / null (canon) / $anonfun$3 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$$anonfun$4 / null (canon) / $anonfun$4 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$$anonfun$f$1 / null (canon) / $anonfun$f$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$$anonfun$f$2 / null (canon) / $anonfun$f$2 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$D$$anonfun$1 / null (canon) / anonfun$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A$D$ (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +AO$$anonfun$5 / null (canon) / anonfun$5 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class AO$ (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +AT$$anonfun$6 / null (canon) / $anonfun$6 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / interface AT (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +#partest -Ydelambdafy:method +A$D$lambda$1 / A$D$lambda$1 (canon) / A$D$lambda$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$lambda$$$anonfun$7$1 / A$lambda$$$anonfun$7$1 (canon) / A$lambda$$$anonfun$7$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$lambda$$$lessinit$greater$1 / A$lambda$$$lessinit$greater$1 (canon) / A$lambda$$$lessinit$greater$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$lambda$$f$1 / A$lambda$$f$1 (canon) / A$lambda$$f$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$lambda$$f$2 / A$lambda$$f$2 (canon) / A$lambda$$f$2 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$lambda$1 / A$lambda$1 (canon) / A$lambda$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$lambda$2 / A$lambda$2 (canon) / A$lambda$2 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$lambda$3 / A$lambda$3 (canon) / A$lambda$3 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +AO$lambda$1 / AO$lambda$1 (canon) / AO$lambda$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +AT$class$lambda$1 / AT$class$lambda$1 (canon) / AT$class$lambda$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +#partest +A / A (canon) / A (simple) +- declared cls: List(class A$B, interface A$C, class A$D$) +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +A$$anon$1 / null (canon) / $anon$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$$anon$3 / null (canon) / $anon$3 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$$anon$4 / null (canon) / $anon$4 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$$anon$5 / null (canon) / $anon$5 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$$anon$6 / null (canon) / $anon$6 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$$anon$7 / null (canon) / $anon$7 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / public A(int) (constr) / null (meth) +- properties : true (local) / false (member) +A$B / A.B (canon) / B (simple) +- declared cls: List() +- enclosing : class A (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +A$C / A.C (canon) / C (simple) +- declared cls: List() +- enclosing : class A (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +A$D$ / A.D$ (canon) / D$ (simple) +- declared cls: List(class A$D$B, interface A$D$C, class A$D$D$) +- enclosing : class A (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +A$D$$anon$2 / null (canon) / anon$2 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A$D$ (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$D$B / Malformed class name (canon) / Malformed class name (simple) +- declared cls: List() +- enclosing : class A$D$ (declaring cls) / class A$D$ (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +A$D$C / Malformed class name (canon) / Malformed class name (simple) +- declared cls: List() +- enclosing : class A$D$ (declaring cls) / class A$D$ (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +A$D$D$ / Malformed class name (canon) / Malformed class name (simple) +- declared cls: List() +- enclosing : class A$D$ (declaring cls) / class A$D$ (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +A$D$KB$1 / null (canon) / Malformed class name (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A$D$ (cls) / null (constr) / public void A$D$.f() (meth) +- properties : Malformed class name (local) / false (member) +A$E$1 / null (canon) / E$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$F$1 / null (canon) / F$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$G$2$ / null (canon) / G$2$ (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$H$1 / null (canon) / H$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$I$1 / null (canon) / I$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$J$2$ / null (canon) / J$2$ (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / public java.lang.Object A.f() (meth) +- properties : true (local) / false (member) +A$K$1 / null (canon) / K$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$L$1 / null (canon) / L$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$M$2$ / null (canon) / M$2$ (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$N$1 / null (canon) / N$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$O$1 / null (canon) / O$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$P$2$ / null (canon) / P$2$ (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +A$Q$1 / null (canon) / Q$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / public A(int) (constr) / null (meth) +- properties : true (local) / false (member) +A$R$1 / null (canon) / R$1 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / public A(int) (constr) / null (meth) +- properties : true (local) / false (member) +A$S$2$ / null (canon) / S$2$ (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class A (cls) / public A(int) (constr) / null (meth) +- properties : true (local) / false (member) +AO / AO (canon) / AO (simple) +- declared cls: List(class AO$B, interface AO$C, class AO$D$) +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +AO$ / AO$ (canon) / AO$ (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +AO$$anon$8 / null (canon) / anon$8 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / class AO$ (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +AO$B / AO.B (canon) / B (simple) +- declared cls: List() +- enclosing : class AO (declaring cls) / class AO (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +AO$C / AO.C (canon) / C (simple) +- declared cls: List() +- enclosing : class AO (declaring cls) / class AO (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +AO$D$ / AO.D$ (canon) / D$ (simple) +- declared cls: List() +- enclosing : class AO (declaring cls) / class AO (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +AT / AT (canon) / AT (simple) +- declared cls: List(class AT$B, interface AT$C, class AT$D$) +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +AT$$anon$9 / null (canon) / $anon$9 (simple) +- declared cls: List() +- enclosing : null (declaring cls) / interface AT (cls) / null (constr) / null (meth) +- properties : true (local) / false (member) +AT$B / AT.B (canon) / B (simple) +- declared cls: List() +- enclosing : interface AT (declaring cls) / interface AT (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +AT$C / AT.C (canon) / C (simple) +- declared cls: List() +- enclosing : interface AT (declaring cls) / interface AT (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +AT$D$ / AT.D$ (canon) / D$ (simple) +- declared cls: List() +- enclosing : interface AT (declaring cls) / interface AT (cls) / null (constr) / null (meth) +- properties : false (local) / true (member) +AT$class / AT$class (canon) / AT$class (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +T / T (canon) / T (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) +T$class / T$class (canon) / T$class (simple) +- declared cls: List() +- enclosing : null (declaring cls) / null (cls) / null (constr) / null (meth) +- properties : false (local) / false (member) diff --git a/test/files/jvm/javaReflection/Classes_1.scala b/test/files/jvm/javaReflection/Classes_1.scala new file mode 100644 index 000000000000..11963e2770ea --- /dev/null +++ b/test/files/jvm/javaReflection/Classes_1.scala @@ -0,0 +1,84 @@ +// See Test.scala for comments + +trait T { def f = 1 } + +class A { + // member class + class B + // member trait + trait C + // member object + object D { + class B + trait C + object D + new T { } + (() => -1) + def f = { class KB } + } + + // anonymous class, not a member + new T { } + + // anonymous function, not a member + (() => 1) + + def f = { + class E + trait F + object G + new T { } + (() => 2) + + if (new Object().hashCode == 1) { + class H + trait I + object J + new T { } + (() => 3) + } else { + () + } + } + + { + class K + trait L + object M + new T { } + (() => 4) + } + + val x = { + class N + trait O + object P + new T { } + (() => 5) + } + + def this(x: Int) { + this() + class Q + trait R + object S + new T { } + (() => () => 5) + } +} + +object AO { + class B + trait C + object D + new T { } + (() => 1) +} + +trait AT { + class B + trait C + object D + new T { } + (() => 1) +} diff --git a/test/files/jvm/javaReflection/Test.scala b/test/files/jvm/javaReflection/Test.scala new file mode 100644 index 000000000000..5b6ef1b57305 --- /dev/null +++ b/test/files/jvm/javaReflection/Test.scala @@ -0,0 +1,137 @@ +/** +Interesting aspects of Java reflection applied to scala classes. TL;DR: you should not use +getSimpleName / getCanonicalName / isAnonymousClass / isLocalClass / isSynthetic. + + - Some methods in Java reflection assume a certain structure in the class names. Scalac + can produce class files that don't respect this structure. Certain methods in reflection + therefore give surprising answers or may even throw an exception. + + In particular, the method "getSimpleName" assumes that classes are named after the Java spec + http://docs.oracle.com/javase/specs/jls/se8/html/jls-13.html#jls-13.1 + + Consider the following Scala example: + class A { object B { class C } } + + The classfile for C has the name "A$B$C", while the classfile for the module B has the + name "A$B$". + + For "cClass.getSimpleName, the implementation first strips the name of the enclosing class, + which produces "C". The implementation then expects a "$" character, which is missing, and + throws an InternalError. + + Consider another example: + trait T + class A { val x = new T {} } + object B { val x = new T {} } + + The anonymous classes are named "A$$anon$1" and "B$$anon$2". If you call "getSimpleName", + you get "$anon$1" (leading $) and "anon$2" (no leading $). + + - There are certain other methods in the Java reflection API that depend on getSimpleName. + These should be avoided, they yield unexpected results: + + - isAnonymousClass is always false. Scala-defined classes are never anonymous for Java + reflection. Java reflection insepects the class name to decide whether a class is + anonymous, based on the name spec referenced above. + Also, the implementation of "isAnonymousClass" calls "getSimpleName", which may throw. + + - isLocalClass: should be true true for local classes (nested classes that are not + members), but not for anonymous classes. Since "isAnonymousClass" is always false, + Java reflection thinks that all Scala-defined anonymous classes are local. + The implementation may also throw, since it uses "isAnonymousClass": + class A { object B { def f = { class KB; new KB } } } + (new A).B.f.getClass.isLocalClass // boom + + - getCanonicalName: uses "getSimpleName" in the implementation. In the first example, + cClass.getCanonicalName also fails with an InternalError. + + - Scala-defined classes are never synthetic for Java reflection. The implementation + checks for the SYNTHETEIC flag, which does not seem to be added by scalac (maybe this + will change some day). +*/ + +object Test { + + def tr[T](m: => T): String = try { + val r = m + if (r == null) "null" + else r.toString + } catch { case e: InternalError => e.getMessage } + + def assertNotAnonymous(c: Class[_]) = { + val an = try { + c.isAnonymousClass + } catch { + // isAnonymousClass is implemented using getSimpleName, which may throw. + case e: InternalError => false + } + assert(!an, c) + } + + def ruleMemberOrLocal(c: Class[_]) = { + // if it throws, then it's because of the call from isLocalClass to isAnonymousClass. + // we know that isAnonymousClass is always false, so it has to be a local class. + val loc = try { c.isLocalClass } catch { case e: InternalError => true } + if (loc) + assert(!c.isMemberClass, c) + if (c.isMemberClass) + assert(!loc, c) + } + + def ruleMemberDeclaring(c: Class[_]) = { + if (c.isMemberClass) + assert(c.getDeclaringClass.getDeclaredClasses.toList.map(_.getName) contains c.getName) + } + + def ruleScalaAnonClassIsLocal(c: Class[_]) = { + if (c.getName contains "$anon$") + assert(c.isLocalClass, c) + } + + def ruleScalaAnonFunInlineIsLocal(c: Class[_]) = { + // exclude lambda classes generated by delambdafy:method. nested closures have both "anonfun" and "lambda". + if (c.getName.contains("$anonfun$") && !c.getName.contains("$lambda$")) + assert(c.isLocalClass, c) + } + + def ruleScalaAnonFunMethodIsToplevel(c: Class[_]) = { + if (c.getName.contains("$lambda$")) + assert(c.getEnclosingClass == null, c) + } + + def showClass(name: String) = { + val c = Class.forName(name) + + println(s"${c.getName} / ${tr(c.getCanonicalName)} (canon) / ${tr(c.getSimpleName)} (simple)") + println( "- declared cls: "+ c.getDeclaredClasses.toList.sortBy(_.getName)) + println(s"- enclosing : ${c.getDeclaringClass} (declaring cls) / ${c.getEnclosingClass} (cls) / ${c.getEnclosingConstructor} (constr) / ${c.getEnclosingMethod} (meth)") + println(s"- properties : ${tr(c.isLocalClass)} (local) / ${c.isMemberClass} (member)") + + assertNotAnonymous(c) + assert(!c.isSynthetic, c) + + ruleMemberOrLocal(c) + ruleMemberDeclaring(c) + ruleScalaAnonClassIsLocal(c) + ruleScalaAnonFunInlineIsLocal(c) + ruleScalaAnonFunMethodIsToplevel(c) + } + + def main(args: Array[String]): Unit = { + def isAnonFunClassName(s: String) = s.contains("$anonfun$") || s.contains("$lambda$") + + val classfiles = new java.io.File(sys.props("partest.output")).listFiles().toList.map(_.getName).collect({ + // exclude files from Test.scala, just take those from Classes_1.scala + case s if !s.startsWith("Test") && s.endsWith(".class") => s.substring(0, s.length - 6) + }).sortWith((a, b) => { + // sort such that first there are all anonymous funcitions, then all other classes. + // within those cathegories, sort lexically. + // this makes the check file smaller: it differs for anonymous functions between -Ydelambdafy:inline/method. + // the other classes are the same. + if (isAnonFunClassName(a)) !isAnonFunClassName(b) || a < b + else !isAnonFunClassName(b) && a < b + }) + + classfiles foreach showClass + } +} \ No newline at end of file diff --git a/test/files/run/t5256c.check b/test/files/run/t5256c.check index 7fcd0eb72285..3eb7b13a97ad 100644 --- a/test/files/run/t5256c.check +++ b/test/files/run/t5256c.check @@ -2,5 +2,5 @@ class A$1 Test.A$1 java.lang.Object { def foo(): Nothing - def (): A$1 + def (): Test.A$1 } diff --git a/versions.properties b/versions.properties index cd53a343f6c3..454df6b75776 100644 --- a/versions.properties +++ b/versions.properties @@ -27,7 +27,7 @@ actors-migration.version.number=1.1.0 jline.version=2.12 # external modules, used internally (not shipped) -partest.version.number=1.0.0 +partest.version.number=1.0.1 scalacheck.version.number=1.11.4 # TODO: modularize the compiler From 2256753502c2c099da17a20d45c3f23974d0eafd Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Tue, 19 Aug 2014 16:58:16 +0200 Subject: [PATCH 511/826] Small cleanup in toTypeKind. --- .../scala/tools/nsc/backend/jvm/BCodeHelpers.scala | 13 ++----------- 1 file changed, 2 insertions(+), 11 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala index aed3654b2ce9..5670715cd3ba 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala @@ -385,17 +385,8 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters { */ def primitiveOrClassToBType(sym: Symbol): BType = { assertClassNotArray(sym) - primitiveTypeMap.getOrElse(sym, classOrImplClassToBType(sym)) - } - - /** - * The ClassBType for a class or interface reference. Asserts that `sym` is not an - * implementation class. - */ - def classOrImplClassToBType(sym: Symbol): ClassBType = { - assertClassNotArrayNotPrimitive(sym) - assert(!sym.isImplClass, s"typeKind of implementation class $sym") - getClassBTypeAndRegisterInnerClass(sym) + assert(!sym.isImplClass, sym) + primitiveTypeMap.getOrElse(sym, getClassBTypeAndRegisterInnerClass(sym)) } /** From 6076d61aef732b89af9d2c803425f90fb0fc4686 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Mon, 1 Sep 2014 17:20:46 -0700 Subject: [PATCH 512/826] SI-8410 Summarize if warnings and not disabled Simplify the conditional and emit the summary if there were buffered warnings and the user didn't explicitly disable this setting. The working assumption is that using fatal-warnings to turn on summaries was either an outdated heuristic or just due to a faulty merge. Or wait, was it for -feature, which is not enabled when warnings are issued against it? --- src/compiler/scala/tools/nsc/Reporting.scala | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/src/compiler/scala/tools/nsc/Reporting.scala b/src/compiler/scala/tools/nsc/Reporting.scala index 6ae5ec3c1d5a..c9782de7c8c9 100644 --- a/src/compiler/scala/tools/nsc/Reporting.scala +++ b/src/compiler/scala/tools/nsc/Reporting.scala @@ -32,17 +32,14 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w def warn(pos: Position, msg: String) = if (option) reporter.warning(pos, msg) else if (!(warnings contains pos)) warnings += ((pos, msg)) - def summarize() = { - def turnedOff = option.isSetByUser && !option - def moreInfos = option.isDefault || settings.fatalWarnings - if (warnings.nonEmpty && !turnedOff && moreInfos) { + def summarize() = + if (warnings.nonEmpty && (option.isDefault || option)) { val numWarnings = warnings.size val warningVerb = if (numWarnings == 1) "was" else "were" val warningCount = countElementsAsString(numWarnings, s"$what warning") reporter.warning(NoPosition, s"there $warningVerb $warningCount; re-run with ${option.name} for details") } - } } // This change broke sbt; I gave it the thrilling name of uncheckedWarnings0 so From 20daa00aa8c6f8f93eca21a2fad51f91a29e3fd8 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Mon, 1 Sep 2014 14:34:49 +0200 Subject: [PATCH 513/826] SI-7931 fix Dscala.repl.vids and some string interpolation typos That nice little `-Dscala.repl.vids` feature regressed in f56f9a3c when a string.format was replaced by string interpolation. The ones in scala-reflect were caught by Xlint (who knew building with Xlint was actually useful...), the other was just luck. --- src/reflect/scala/reflect/internal/AnnotationInfos.scala | 4 ++-- src/reflect/scala/reflect/internal/ReificationSupport.scala | 2 +- src/repl/scala/tools/nsc/interpreter/MemberHandlers.scala | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/reflect/scala/reflect/internal/AnnotationInfos.scala b/src/reflect/scala/reflect/internal/AnnotationInfos.scala index f814a746f5db..fcef4dd6be6b 100644 --- a/src/reflect/scala/reflect/internal/AnnotationInfos.scala +++ b/src/reflect/scala/reflect/internal/AnnotationInfos.scala @@ -388,11 +388,11 @@ trait AnnotationInfos extends api.Annotations { self: SymbolTable => case Literal(const) => LiteralAnnotArg(const) case Apply(ArrayModule, args) => ArrayAnnotArg(args map encodeJavaArg toArray) case Apply(Select(New(tpt), nme.CONSTRUCTOR), args) => NestedAnnotArg(treeToAnnotation(arg)) - case _ => throw new Exception("unexpected java argument shape $arg: literals, arrays and nested annotations are supported") + case _ => throw new Exception(s"unexpected java argument shape $arg: literals, arrays and nested annotations are supported") } def encodeJavaArgs(args: List[Tree]): List[(Name, ClassfileAnnotArg)] = args match { case AssignOrNamedArg(Ident(name), arg) :: rest => (name, encodeJavaArg(arg)) :: encodeJavaArgs(rest) - case arg :: rest => throw new Exception("unexpected java argument shape $arg: only AssignOrNamedArg trees are supported") + case arg :: rest => throw new Exception(s"unexpected java argument shape $arg: only AssignOrNamedArg trees are supported") case Nil => Nil } val atp = tpt.tpe diff --git a/src/reflect/scala/reflect/internal/ReificationSupport.scala b/src/reflect/scala/reflect/internal/ReificationSupport.scala index 2caa30d27e76..759bd2e7919f 100644 --- a/src/reflect/scala/reflect/internal/ReificationSupport.scala +++ b/src/reflect/scala/reflect/internal/ReificationSupport.scala @@ -866,7 +866,7 @@ trait ReificationSupport { self: SymbolTable => protected def mkCases(cases: List[Tree]): List[CaseDef] = cases.map { case c: CaseDef => c - case tree => throw new IllegalArgumentException("$tree is not valid representation of pattern match case") + case tree => throw new IllegalArgumentException(s"$tree is not valid representation of pattern match case") } object SyntacticPartialFunction extends SyntacticPartialFunctionExtractor { diff --git a/src/repl/scala/tools/nsc/interpreter/MemberHandlers.scala b/src/repl/scala/tools/nsc/interpreter/MemberHandlers.scala index f4cbcb50fefb..a37cdc2ec84b 100644 --- a/src/repl/scala/tools/nsc/interpreter/MemberHandlers.scala +++ b/src/repl/scala/tools/nsc/interpreter/MemberHandlers.scala @@ -116,7 +116,7 @@ trait MemberHandlers { else any2stringOf(path, maxStringElements) val vidString = - if (replProps.vids) s"""" + " @ " + "%%8x".format(System.identityHashCode($path)) + " """.trim + if (replProps.vids) s"""" + f"@$${System.identityHashCode($path)}%8x" + """" else "" """ + "%s%s: %s = " + %s""".format(string2code(prettyName), vidString, string2code(req typeOf name), resultString) From 0a6dd09d7585448d0c66835a2d2618eb12a47786 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Sun, 24 Aug 2014 10:22:20 +0200 Subject: [PATCH 514/826] Fix assertThrows, and the behaviors that it shadowed The test in StdNamesTest was introduced in cff8b569, where newTermName would throw on a negative length. In b090f97 this was changed to fix the negative length, but the test was not adapted (as it didn't fail). --- .../scala/tools/nsc/symtab/CannotHaveAttrsTest.scala | 4 ++-- .../scala/tools/nsc/symtab/FreshNameExtractorTest.scala | 4 ++-- test/junit/scala/tools/nsc/symtab/StdNamesTest.scala | 8 ++++++-- test/junit/scala/tools/testing/AssertUtil.scala | 2 ++ 4 files changed, 12 insertions(+), 6 deletions(-) diff --git a/test/junit/scala/tools/nsc/symtab/CannotHaveAttrsTest.scala b/test/junit/scala/tools/nsc/symtab/CannotHaveAttrsTest.scala index 355771bf0410..d424f127104b 100644 --- a/test/junit/scala/tools/nsc/symtab/CannotHaveAttrsTest.scala +++ b/test/junit/scala/tools/nsc/symtab/CannotHaveAttrsTest.scala @@ -47,7 +47,7 @@ class CannotHaveAttrsTest { assertEquals(t.tpe, NoType) } - @Test + @Test @org.junit.Ignore // SI-8816 def nonDefaultPosAssignmentFails = { val pos = new OffsetPosition(null, 0) attrlessTrees.foreach { t => @@ -56,7 +56,7 @@ class CannotHaveAttrsTest { } } - @Test + @Test @org.junit.Ignore // SI-8816 def nonDefaultTpeAssignmentFails = { val tpe = typeOf[Int] attrlessTrees.foreach { t => diff --git a/test/junit/scala/tools/nsc/symtab/FreshNameExtractorTest.scala b/test/junit/scala/tools/nsc/symtab/FreshNameExtractorTest.scala index cf09abdfffdb..effbfb2f7c0b 100644 --- a/test/junit/scala/tools/nsc/symtab/FreshNameExtractorTest.scala +++ b/test/junit/scala/tools/nsc/symtab/FreshNameExtractorTest.scala @@ -36,7 +36,7 @@ class FreshNameExtractorTest { } } - @Test + @Test @org.junit.Ignore // SI-8818 def extractionsFailsIfNameDoesntEndWithNumber = { val Creator = new FreshNameCreator(prefixes.head) val Extractor = new FreshNameExtractor(prefixes.head) @@ -44,4 +44,4 @@ class FreshNameExtractorTest { val Extractor(_) = TermName(Creator.newName("foo") + "bar") } } -} \ No newline at end of file +} diff --git a/test/junit/scala/tools/nsc/symtab/StdNamesTest.scala b/test/junit/scala/tools/nsc/symtab/StdNamesTest.scala index 4a39cf9d485c..524d2e45e09d 100644 --- a/test/junit/scala/tools/nsc/symtab/StdNamesTest.scala +++ b/test/junit/scala/tools/nsc/symtab/StdNamesTest.scala @@ -15,11 +15,15 @@ class StdNamesTest { @Test def testNewTermNameInvalid(): Unit = { - assertThrows[IllegalArgumentException](newTermName("foo".toCharArray, 0, -1)) - assertThrows[IllegalArgumentException](newTermName("foo".toCharArray, 0, 0)) assertThrows[IllegalArgumentException](newTermName("foo".toCharArray, -1, 1)) } + @Test + def testNewTermNameNegativeLenght(): Unit = { + assertEquals(nme.EMPTY, newTermName("foo".toCharArray, 0, -1)) + assertEquals(nme.EMPTY, newTermName("foo".toCharArray, 0, 0)) + } + @Test def testUnspecializedName(): Unit = { def test(expected: Name, nme: Name) { diff --git a/test/junit/scala/tools/testing/AssertUtil.scala b/test/junit/scala/tools/testing/AssertUtil.scala index 9a97c5114fca..9b4833d46b2a 100644 --- a/test/junit/scala/tools/testing/AssertUtil.scala +++ b/test/junit/scala/tools/testing/AssertUtil.scala @@ -19,6 +19,8 @@ object AssertUtil { val clazz = manifest.runtimeClass if (!clazz.isAssignableFrom(e.getClass)) throw e + else return } + throw new AssertionError("Expression did not throw!") } } From b562d965dc30bb1fdd9433a6675bfe8e38b8c667 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Fri, 22 Aug 2014 14:55:08 +0200 Subject: [PATCH 515/826] -Ystatistics accepts a list of phases, cleanups in MultiChoiceSetting MultiChoiceSetting and Xlint with its deprecated aliases is now a bit simpler, but there's still room for improvement, as noted in comments. --- src/compiler/scala/tools/nsc/Global.scala | 2 +- src/compiler/scala/tools/nsc/MainBench.scala | 2 +- .../tools/nsc/backend/opt/Inliners.scala | 2 +- .../tools/nsc/settings/AbsScalaSettings.scala | 2 +- .../tools/nsc/settings/MutableSettings.scala | 122 ++++++++--- .../tools/nsc/settings/ScalaSettings.scala | 25 ++- .../scala/tools/nsc/settings/Warnings.scala | 194 +++++++----------- .../scala/tools/nsc/typechecker/Infer.scala | 2 +- .../scala/tools/nsc/util/StatisticsInfo.scala | 4 +- .../tools/nsc/settings/SettingsTest.scala | 63 +++++- 10 files changed, 254 insertions(+), 164 deletions(-) diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 82ffb35c3f29..452081cff165 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -1372,7 +1372,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter) runCheckers() // output collected statistics - if (settings.Ystatistics) + if (settings.YstatisticsEnabled) statistics.print(phase) advancePhase() diff --git a/src/compiler/scala/tools/nsc/MainBench.scala b/src/compiler/scala/tools/nsc/MainBench.scala index 03190a63f31b..eb56c8a2306f 100644 --- a/src/compiler/scala/tools/nsc/MainBench.scala +++ b/src/compiler/scala/tools/nsc/MainBench.scala @@ -24,7 +24,7 @@ object MainBench extends Driver with EvalLoop { var start = System.nanoTime() for (i <- 0 until NIter) { if (i == NIter-1) { - theCompiler.settings.Ystatistics.value = true + theCompiler.settings.YstatisticsPhases.value = theCompiler.settings.YstatisticsPhases.default.get Statistics.enabled = true } process(args) diff --git a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala index 8df3969c49e7..351eb23c4cdd 100644 --- a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala +++ b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala @@ -283,7 +283,7 @@ abstract class Inliners extends SubComponent { } val tfa = new analysis.MTFAGrowable() - tfa.stat = global.settings.Ystatistics.value + tfa.stat = global.settings.YstatisticsEnabled val staleOut = new mutable.ListBuffer[BasicBlock] val splicedBlocks = mutable.Set.empty[BasicBlock] val staleIn = mutable.Set.empty[BasicBlock] diff --git a/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala index d0b8fd70ed7c..cd2cb183b385 100644 --- a/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala @@ -29,7 +29,7 @@ trait AbsScalaSettings { def ChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: String): ChoiceSetting def IntSetting(name: String, descr: String, default: Int, range: Option[(Int, Int)], parser: String => Option[Int]): IntSetting def MultiStringSetting(name: String, helpArg: String, descr: String): MultiStringSetting - def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: Option[() => Unit])(helper: MultiChoiceSetting => String): MultiChoiceSetting + def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], descriptions: List[String], default: Option[List[String]]): MultiChoiceSetting def OutputSetting(outputDirs: OutputDirs, default: String): OutputSetting def PathSetting(name: String, descr: String, default: String): PathSetting def PhasesSetting(name: String, descr: String, default: String): PhasesSetting diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala index f26192f88a51..b9b9257d637d 100644 --- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala @@ -209,12 +209,11 @@ class MutableSettings(val errorFn: String => Unit) def BooleanSetting(name: String, descr: String) = add(new BooleanSetting(name, descr)) def ChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: String) = add(new ChoiceSetting(name, helpArg, descr, choices, default)) - def IntSetting(name: String, descr: String, default: Int, range: Option[(Int, Int)], parser: String => Option[Int]) = add(new IntSetting(name, descr, default, range, parser)) + def IntSetting(name: String, descr: String, default: Int, range: Option[(Int, Int)], parser: String => Option[Int]) = + add(new IntSetting(name, descr, default, range, parser)) def MultiStringSetting(name: String, arg: String, descr: String) = add(new MultiStringSetting(name, arg, descr)) - def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: Option[() => Unit] = None)( - helper: MultiChoiceSetting => String = _ => choices.mkString(f"$descr:%n", f"%n ", f"%n") - ) = - add(new MultiChoiceSetting(name, helpArg, descr, choices, default, helper)) + def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], descriptions: List[String], default: Option[List[String]] = None) = + add(new MultiChoiceSetting(name, helpArg, descr, choices, descriptions, default)) def OutputSetting(outputDirs: OutputDirs, default: String) = add(new OutputSetting(outputDirs, default)) def PhasesSetting(name: String, descr: String, default: String = "") = add(new PhasesSetting(name, descr, default)) def StringSetting(name: String, arg: String, descr: String, default: String) = add(new StringSetting(name, arg, descr, default)) @@ -553,57 +552,132 @@ class MutableSettings(val errorFn: String => Unit) } } - /** A setting that receives any combination of enumerated values, - * including "_" to mean all values and "help" for verbose info. - * In non-colonated mode, stops consuming args at the first - * non-value, instead of at the next option, as for a multi-string. + /** + * A setting that receives multiple values. There are two modes + * - choosing: the setting has a list of allowed chioces. + * - These choices can be positive or negative, for exmample "-option:positive,-negative" + * - If an option is both enabled positively and negatively, the positive wins + * - The choice "_" enables all choices that have not explicitly been disabled + * + * - !choosing: the setting accumulates all arguments. + * + * Arguments can be provided in colonated or non-colonated mode, i.e. "-option a b" or + * "-option:a,b". Note that arguments starting with a "-" can only be provided in colonated mode, + * otherwise they are interpreted as a new option. + * + * In colonated and choosing mode, the setting stops consuming arguments at the first non-choice, + * i.e. "-option a b c" only consumes "a" and "b" if "c" is not a valid choice. + * + * @param name command-line setting name, eg "-Xlint" + * @param arg description of the kind of arguments that need to be passed, eg "warning" + * @param descr description of the setting + * @param choices a list of allowed arguments. if empty, accepts any argument that doesn't start with "-" + * @param descriptions a description for each choice (for the help message), may be empty if no descriptions are necessary + * @param default default arguments, if none are provided */ class MultiChoiceSetting private[nsc]( name: String, arg: String, descr: String, override val choices: List[String], - val default: Option[() => Unit], - helper: MultiChoiceSetting => String + val descriptions: List[String], + val default: Option[List[String]] ) extends MultiStringSetting(name, s"_,$arg,-$arg", s"$descr: `_' for all, `$name:help' to list") { private def badChoice(s: String, n: String) = errorFn(s"'$s' is not a valid choice for '$name'") - private def choosing = choices.nonEmpty + private def choosing = choices.nonEmpty // choices are known, error on invalid args private def isChoice(s: String) = (s == "_") || (choices contains (s stripPrefix "-")) private var sawHelp = false private var sawAll = false - private val adderAll = () => sawAll = true - private val noargs = () => errorFn(s"'$name' requires an option. See '$name:help'.") + + private def pos(s: String) = s stripPrefix "-" + + /** + * This override takes care of including all possible choices in case the "_" argument was + * passed. It adds the choices that have not explicitly been enabled or disabled. This ensures + * that "this contains x" is consistent with "this.value contains x". + * + * The explicitly enabled / disabled options are stored in the underlying value [[v]], disabled + * ones are stored as "-arg". + * + * The fact that value and v are not the same leaks in some cases. For example, you should never + * use "value += arg", because that expands to "value = value + arg". In case sawAll is true, + * this would propagate all choices enabled by sawAll into the underlying v. + * + * Instead of "value += arg", you should use "this.add(arg)". I haven't found a good way to + * enforce that. + */ + override def value: List[String] = { + if (!sawAll) v + else { + // add only those choices which have not explicitly been enabled or disabled. + val fromAll = choices.filterNot(c => v.exists(pos(_) == c)) + v ++ fromAll + } + } + + /** + * Add an argument to the list of values. + */ + def add(arg: String) = { + if (choosing && !isChoice(arg)) badChoice(arg, name) + if (arg == "_") { + sawAll = true + value = v // the value_= setter has side effects, make sure to execute them. + } else { + val posArg = pos(arg) + if (arg == posArg) { + // positive overrides existing negative. so we filter existing (pos or neg), and add the arg + value = v.filterNot(pos(_) == posArg) :+ arg + } else { + // negative arg is only added if the arg doesn't exist yet (pos or neg) + if (!v.exists(pos(_) == posArg)) value = v :+ arg // not value += arg, see doc of the "value" getter + } + } + } override protected def tts(args: List[String], halting: Boolean) = { val added = collection.mutable.ListBuffer.empty[String] + def tryArg(arg: String) = arg match { - case "_" if choosing => addAll() case "help" if choosing => sawHelp = true - case s if !choosing || isChoice(s) => added += s + case s if !choosing || isChoice(s) => added += s // this case also adds "_" case s => badChoice(s, name) } + + // if "halting" is true, the args were not specified as , separated after a : + // but space separated after a space. we stop consuming args when seeing + // - an arg starting with a "-", that is a new option + // - if the choices are known (choosing), on the first non-choice def stoppingAt(arg: String) = (arg startsWith "-") || (choosing && !isChoice(arg)) + def loop(args: List[String]): List[String] = args match { case arg :: _ if halting && stoppingAt(arg) => args case arg :: rest => tryArg(arg) ; loop(rest) case Nil => Nil } + val rest = loop(args) - if (rest.size == args.size) - (default getOrElse noargs)() // if no arg consumed, trigger default action or error - else - value ++= added.toList // update all new settings at once + if (rest.size == args.size) default match { // if no arg consumed, use defaults or error + case Some(defaults) => defaults foreach add + case None => errorFn(s"'$name' requires an option. See '$name:help'.") + } else { + added.toList foreach add + } + Some(rest) } def isHelping: Boolean = sawHelp - def help: String = helper(this) - def addAll(): Unit = (default getOrElse adderAll)() - // the semantics is: s is enabled, i.e., either s or (_ but not -s) - override def contains(s: String) = isChoice(s) && (value contains s) || (sawAll && !(value contains s"-$s")) + def help: String = { + val choiceLength = choices.map(_.length).max + 1 + val formatStr = s" %-${choiceLength}s %s" + choices.zipAll(descriptions, "", "").map { + case (arg, descr) => formatStr.format(arg, descr) + } mkString (f"$descr%n", f"%n", "") + } } /** A setting that accumulates all strings supplied to it, diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala index 8e695986141b..1609aa5ff7b2 100644 --- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala @@ -84,13 +84,9 @@ trait ScalaSettings extends AbsScalaSettings name = "-language", helpArg = "feature", descr = description, - choices = features map (_._1) - ) { s => - val helpline: ((String, String)) => String = { - case (name, text) => f" $name%-25s $text%n" - } - features map helpline mkString (f"$description:%n", "", f"%n") - } + choices = features map (_._1), + descriptions = features map (_._2) + ) } /* @@ -193,7 +189,6 @@ trait ScalaSettings extends AbsScalaSettings val Ygenjavap = StringSetting ("-Ygen-javap", "dir", "Generate a parallel output directory of .javap files.", "") val Ygenasmp = StringSetting ("-Ygen-asmp", "dir", "Generate a parallel output directory of .asmp files (ie ASM Textifier output).", "") val Ydumpclasses = StringSetting ("-Ydump-classes", "dir", "Dump the generated bytecode to .class files (useful for reflective compilation that utilizes in-memory classloaders).", "") - val Ystatistics = BooleanSetting ("-Ystatistics", "Print compiler statistics.") andThen (scala.reflect.internal.util.Statistics.enabled = _) val stopAfter = PhasesSetting ("-Ystop-after", "Stop after") withAbbreviation ("-stop") // backward compat val stopBefore = PhasesSetting ("-Ystop-before", "Stop before") val Yrangepos = BooleanSetting ("-Yrangepos", "Use range positions for syntax trees.") @@ -217,6 +212,20 @@ trait ScalaSettings extends AbsScalaSettings private def removalIn212 = "This flag is scheduled for removal in 2.12. If you have a case where you need this flag then please report a bug." + val YstatisticsPhases = { + val phases = List("parser", "typer", "patmat", "erasure", "cleanup") + val description = "Print compiler statistics for specific phases" + MultiChoiceSetting( + name = "-Ystatistics", + helpArg = "phase", + descr = description, + choices = phases, + descriptions = Nil, + default = Some(List("_"))) withPostSetHook { _ => scala.reflect.internal.util.Statistics.enabled = true } + } + + def YstatisticsEnabled = YstatisticsPhases.value.nonEmpty + /** Area-specific debug output. */ val Ydocdebug = BooleanSetting("-Ydoc-debug", "Trace all scaladoc activity.") diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala index 4c3763330190..771543ec7788 100644 --- a/src/compiler/scala/tools/nsc/settings/Warnings.scala +++ b/src/compiler/scala/tools/nsc/settings/Warnings.scala @@ -17,145 +17,93 @@ trait Warnings { // Warning semantics. val fatalWarnings = BooleanSetting("-Xfatal-warnings", "Fail the compilation if there are any warnings.") - // These additional warnings are all so noisy as to be useless in their - // present form, but have the potential to offer useful info. - protected def allWarnings = lintWarnings ++ List( - warnDeadCode, - warnValueDiscard, - warnNumericWiden, - warnUnused, // SI-7712, SI-7707 warnUnused not quite ready for prime-time - warnUnusedImport, // currently considered too noisy for general use - warnValueOverrides // currently turned off as experimental - ) - // These warnings should be pretty quiet unless you're doing - // something inadvisable. - protected def lintWarnings = List( - warnInaccessible, - warnNullaryOverride, - warnNullaryUnit, - warnAdaptedArgs, - warnInferAny, - warnMissingInterpolator, - warnDocDetached, - warnPrivateShadow, - warnTypeParameterShadow, - warnPolyImplicitOverload, - warnOptionImplicit, - warnDelayedInit, - warnByNameRightAssociative, - warnPackageObjectClasses, - warnUnsoundMatch - ) - - // Individual warnings. They can be set with -Ywarn. - private def nonlintflag(name: String, text: String): BooleanSetting = BooleanSetting(name, text) - - val warnDeadCode = nonlintflag("-Ywarn-dead-code", - "Warn when dead code is identified.") - val warnValueDiscard = nonlintflag("-Ywarn-value-discard", - "Warn when non-Unit expression results are unused.") - val warnNumericWiden = nonlintflag("-Ywarn-numeric-widen", - "Warn when numerics are widened.") - val warnUnused = nonlintflag("-Ywarn-unused", - "Warn when local and private vals, vars, defs, and types are are unused") - val warnUnusedImport = nonlintflag("-Ywarn-unused-import", - "Warn when imports are unused") - - // Lint warnings that have no -Y avatar, created with new instead of the autoregistering factory method. - // They evaluate true if set to true or else are unset but -Xlint is true - private def lintflag(name: String, text: String): BooleanSetting = - new BooleanSetting(name, text) { - override def value = if (isSetByUser) super.value else xlint - } + // Non-lint warnings - val warnAdaptedArgs = lintflag("adapted-args", - "Warn if an argument list is modified to match the receiver.") - val warnNullaryUnit = lintflag("nullary-unit", - "Warn when nullary methods return Unit.") - val warnInaccessible = lintflag("inaccessible", - "Warn about inaccessible types in method signatures.") - val warnNullaryOverride = lintflag("nullary-override", - "Warn when non-nullary `def f()' overrides nullary `def f'.") - val warnInferAny = lintflag("infer-any", - "Warn when a type argument is inferred to be `Any`.") - val warnMissingInterpolator = lintflag("missing-interpolator", - "A string literal appears to be missing an interpolator id.") - val warnDocDetached = lintflag("doc-detached", - "A ScalaDoc comment appears to be detached from its element.") - val warnPrivateShadow = lintflag("private-shadow", - "A private field (or class parameter) shadows a superclass field.") - val warnTypeParameterShadow = lintflag("type-parameter-shadow", - "A local type parameter shadows a type already in scope.") - val warnPolyImplicitOverload = lintflag("poly-implicit-overload", - "Parameterized overloaded implicit methods are not visible as view bounds") - val warnOptionImplicit = lintflag("option-implicit", - "Option.apply used implicit view.") - val warnDelayedInit = lintflag("delayedinit-select", - "Selecting member of DelayedInit") - val warnByNameRightAssociative = lintflag("by-name-right-associative", - "By-name parameter of right associative operator") - val warnPackageObjectClasses = lintflag("package-object-classes", - "Class or object defined in package object") - val warnUnsoundMatch = lintflag("unsound-match", - "Pattern match may not be typesafe") + val warnDeadCode = BooleanSetting("-Ywarn-dead-code", "Warn when dead code is identified.") + val warnValueDiscard = BooleanSetting("-Ywarn-value-discard", "Warn when non-Unit expression results are unused.") + val warnNumericWiden = BooleanSetting("-Ywarn-numeric-widen", "Warn when numerics are widened.") + // SI-7712, SI-7707 warnUnused not quite ready for prime-time + val warnUnused = BooleanSetting("-Ywarn-unused", "Warn when local and private vals, vars, defs, and types are are unused.") + // currently considered too noisy for general use + val warnUnusedImport = BooleanSetting("-Ywarn-unused-import", "Warn when imports are unused.") // Experimental lint warnings that are turned off, but which could be turned on programmatically. // These warnings are said to blind those who dare enable them. // They are not activated by -Xlint and can't be enabled on the command line. - val warnValueOverrides = { - val flag = lintflag("value-overrides", "Generated value class method overrides an implementation") + val warnValueOverrides = { // currently turned off as experimental. creaded using constructor (new BS), so not available on the command line. + val flag = new BooleanSetting("value-overrides", "Generated value class method overrides an implementation") flag.value = false flag } - // The Xlint warning group. - private val xlint = new BooleanSetting("-Zunused", "True if -Xlint or -Xlint:_") - // On -Xlint or -Xlint:_, set xlint, otherwise set the lint warning unless already set true - val lint = { - val description = "Enable or disable specific warnings" - val choices = (lintWarnings map (_.name)).sorted - MultiChoiceSetting( - name = "-Xlint", - helpArg = "warning", - descr = description, - choices = choices, - default = Some(() => xlint.value = true) - ) { s => - def helpline(n: String) = lintWarnings.find(_.name == n).map(w => f" ${w.name}%-25s ${w.helpDescription}%n") - choices flatMap (helpline(_)) mkString (f"$description:%n", "", f"%n") - } withPostSetHook { x => - val Neg = "-" - def setPolitely(b: BooleanSetting, v: Boolean) = if (!b.isSetByUser || !b) b.value = v - def set(w: String, v: Boolean) = lintWarnings find (_.name == w) foreach (setPolitely(_, v)) - def propagate(ss: List[String]): Unit = ss match { - case w :: rest => if (w startsWith Neg) set(w stripPrefix Neg, false) else set(w, true) ; propagate(rest) - case Nil => () - } - propagate(x.value) - } - } + // Lint warnings + + def warnAdaptedArgs = lint contains "adapted-args" + def warnNullaryUnit = lint contains "nullary-unit" + def warnInaccessible = lint contains "inaccessible" + def warnNullaryOverride = lint contains "nullary-override" + def warnInferAny = lint contains "infer-any" + def warnMissingInterpolator = lint contains "missing-interpolator" + def warnDocDetached = lint contains "doc-detached" + def warnPrivateShadow = lint contains "private-shadow" + def warnTypeParameterShadow = lint contains "type-parameter-shadow" + def warnPolyImplicitOverload = lint contains "poly-implicit-overload" + def warnOptionImplicit = lint contains "option-implicit" + def warnDelayedInit = lint contains "delayedinit-select" + def warnByNameRightAssociative = lint contains "by-name-right-associative" + def warnPackageObjectClasses = lint contains "package-object-classes" + def warnUnsoundMatch = lint contains "unsound-match" // Lint warnings that are currently -Y, but deprecated in that usage @deprecated("Use warnAdaptedArgs", since="2.11.2") - val YwarnAdaptedArgs = BooleanSetting("-Ywarn-adapted-args", - "Warn if an argument list is modified to match the receiver.") enabling List(warnAdaptedArgs) - //withDeprecationMessage "Enable -Xlint:adapted-args" + def YwarnAdaptedArgs = warnAdaptedArgs @deprecated("Use warnNullaryUnit", since="2.11.2") - val YwarnNullaryUnit = BooleanSetting("-Ywarn-nullary-unit", - "Warn when nullary methods return Unit.") enabling List(warnNullaryUnit) - //withDeprecationMessage "Enable -Xlint:nullary-unit" + def YwarnNullaryUnit = warnNullaryUnit @deprecated("Use warnInaccessible", since="2.11.2") - val YwarnInaccessible = BooleanSetting("-Ywarn-inaccessible", - "Warn about inaccessible types in method signatures.") enabling List(warnInaccessible) - //withDeprecationMessage "Enable -Xlint:inaccessible" + def YwarnInaccessible = warnInaccessible @deprecated("Use warnNullaryOverride", since="2.11.2") - val YwarnNullaryOverride = BooleanSetting("-Ywarn-nullary-override", - "Warn when non-nullary `def f()' overrides nullary `def f'.") enabling List(warnNullaryOverride) - //withDeprecationMessage "Enable -Xlint:nullary-override" + def YwarnNullaryOverride = warnNullaryOverride @deprecated("Use warnInferAny", since="2.11.2") - val YwarnInferAny = BooleanSetting("-Ywarn-infer-any", - "Warn when a type argument is inferred to be `Any`.") enabling List(warnInferAny) - //withDeprecationMessage "Enable -Xlint:infer-any" + def YwarnInferAny = warnInferAny + + // The Xlint warning group. + val lint: MultiChoiceSetting = { + val description = "Enable or disable specific warnings" + + val choices = List( + ("adapted-args", "Warn if an argument list is modified to match the receiver.", true), + ("nullary-unit", "Warn when nullary methods return Unit.", true), + ("inaccessible", "Warn about inaccessible types in method signatures.", true), + ("nullary-override", "Warn when non-nullary `def f()' overrides nullary `def f'.", true), + ("infer-any", "Warn when a type argument is inferred to be `Any`.", true), + ("missing-interpolator", "A string literal appears to be missing an interpolator id.", false), + ("doc-detached", "A ScalaDoc comment appears to be detached from its element.", false), + ("private-shadow", "A private field (or class parameter) shadows a superclass field.", false), + ("type-parameter-shadow", "A local type parameter shadows a type already in scope.", false), + ("poly-implicit-overload", "Parameterized overloaded implicit methods are not visible as view bounds.", false), + ("option-implicit", "Option.apply used implicit view.", false), + ("delayedinit-select", "Selecting member of DelayedInit", false), + ("by-name-right-associative", "By-name parameter of right associative operator.", false), + ("package-object-classes", "Class or object defined in package object.", false), + ("unsound-match", "Pattern match may not be typesafe.", false) + ).sorted + + for (c <- choices.filter(_._3)) { + BooleanSetting("-Ywarn-"+ c._1, c._2) withPostSetHook { s => + if (s) lint.add(c._1) + else lint.add("-" + c._1) + } // withDeprecationMessage s"Enable -Xlint:${c._1}" + } + + MultiChoiceSetting( + name = "-Xlint", + helpArg = "warning", + descr = description, + choices = choices map (_._1), + descriptions = choices map (_._2), + default = Some(List("_")) + ) + } private lazy val warnSelectNullable = BooleanSetting("-Xcheck-null", "This option is obsolete and does nothing.") diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index fb7651ffd6ee..421021163ec4 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -552,7 +552,7 @@ trait Infer extends Checkable { } case _ => context.tree.pos } - if (settings.warnInferAny.value && context.reportErrors && canWarnAboutAny) { + if (settings.warnInferAny && context.reportErrors && canWarnAboutAny) { foreachWithIndex(targs) ((targ, idx) => targ.typeSymbol match { case sym @ (AnyClass | AnyValClass) => diff --git a/src/compiler/scala/tools/nsc/util/StatisticsInfo.scala b/src/compiler/scala/tools/nsc/util/StatisticsInfo.scala index 225f6ca68eec..a5d579dc37a5 100644 --- a/src/compiler/scala/tools/nsc/util/StatisticsInfo.scala +++ b/src/compiler/scala/tools/nsc/util/StatisticsInfo.scala @@ -14,12 +14,10 @@ abstract class StatisticsInfo { import global._ import scala.reflect.internal.TreesStats.nodeByType - val phasesShown = List("parser", "typer", "patmat", "erasure", "cleanup") - val retainedCount = Statistics.newCounter("#retained tree nodes") val retainedByType = Statistics.newByClass("#retained tree nodes by type")(Statistics.newCounter("")) - def print(phase: Phase) = if (phasesShown contains phase.name) { + def print(phase: Phase) = if (settings.YstatisticsPhases contains phase.name) { inform("*** Cumulative statistics at phase " + phase) retainedCount.value = 0 for (c <- retainedByType.keys) diff --git a/test/junit/scala/tools/nsc/settings/SettingsTest.scala b/test/junit/scala/tools/nsc/settings/SettingsTest.scala index 960d7f8ac1dc..a0e015be32d7 100644 --- a/test/junit/scala/tools/nsc/settings/SettingsTest.scala +++ b/test/junit/scala/tools/nsc/settings/SettingsTest.scala @@ -39,7 +39,7 @@ class SettingsTest { } // for the given args, select the desired setting - private def check(args: String*)(b: MutableSettings => MutableSettings#BooleanSetting): MutableSettings#BooleanSetting = { + private def check(args: String*)(b: MutableSettings => Boolean): Boolean = { val s = new MutableSettings(msg => throw new IllegalArgumentException(msg)) val (ok, residual) = s.processArguments(args.toList, processAll = true) assert(residual.isEmpty) @@ -54,7 +54,68 @@ class SettingsTest { @Test def anonymousLintersCanBeNamed() { assertTrue(check("-Xlint")(_.warnMissingInterpolator)) // among Xlint assertFalse(check("-Xlint:-missing-interpolator")(_.warnMissingInterpolator)) + + // positive overrides negative, but not the other way around + assertTrue(check("-Xlint:-missing-interpolator,missing-interpolator")(_.warnMissingInterpolator)) + assertTrue(check("-Xlint:-missing-interpolator", "-Xlint:missing-interpolator")(_.warnMissingInterpolator)) + + assertTrue(check("-Xlint:missing-interpolator,-missing-interpolator")(_.warnMissingInterpolator)) + assertTrue(check("-Xlint:missing-interpolator", "-Xlint:-missing-interpolator")(_.warnMissingInterpolator)) + + // -Xlint:_ adds all possible choices, but explicit negative settings will override + assertFalse(check("-Xlint:-missing-interpolator,_")(_.warnMissingInterpolator)) + assertFalse(check("-Xlint:-missing-interpolator", "-Xlint:_")(_.warnMissingInterpolator)) + assertFalse(check("-Xlint:_", "-Xlint:-missing-interpolator")(_.warnMissingInterpolator)) + assertFalse(check("-Xlint:_,-missing-interpolator")(_.warnMissingInterpolator)) + + // -Xlint is the same as -Xlint:_ assertFalse(check("-Xlint:-missing-interpolator", "-Xlint")(_.warnMissingInterpolator)) assertFalse(check("-Xlint", "-Xlint:-missing-interpolator")(_.warnMissingInterpolator)) + + // combination of positive, negative and _ + assertTrue(check("-Xlint:_,-missing-interpolator,missing-interpolator")(_.warnMissingInterpolator)) + assertTrue(check("-Xlint:-missing-interpolator,_,missing-interpolator")(_.warnMissingInterpolator)) + assertTrue(check("-Xlint:-missing-interpolator,missing-interpolator,_")(_.warnMissingInterpolator)) + assertTrue(check("-Xlint:missing-interpolator,-missing-interpolator,_")(_.warnMissingInterpolator)) + assertTrue(check("-Xlint:missing-interpolator,_,-missing-interpolator")(_.warnMissingInterpolator)) + } + + @Test def xLintInvalidChoices(): Unit = { + assertThrows[IllegalArgumentException](check("-Xlint:-_")(_.warnAdaptedArgs)) + assertThrows[IllegalArgumentException](check("-Xlint:-warn-adapted-args")(_.warnAdaptedArgs)) // "warn-" should not be there + } + + @Test def xLintNonColonated(): Unit = { + assertTrue(check("-Xlint", "adapted-args", "-deprecation")(_.warnAdaptedArgs)) + assertFalse(check("-Xlint", "adapted-args", "-deprecation")(_.warnMissingInterpolator)) + assertTrue(check("-Xlint", "adapted-args", "missing-interpolator", "-deprecation")(s => s.warnMissingInterpolator && s.warnAdaptedArgs)) + assertThrows[IllegalArgumentException](check("-Xlint", "adapted-args", "-missing-interpolator")(_.warnAdaptedArgs)) // non-colonated: cannot provide negative args + } + + @Test def xLintContainsValues(): Unit = { + // make sure that lint.contains and lint.value.contains are consistent + def t(s: MutableSettings, v: String) = { + val r = s.lint.contains(v) + assertSame(r, s.lint.value.contains(v)) + r + } + + assertTrue(check("-Xlint")(t(_, "adapted-args"))) + assertTrue(check("-Xlint:_")(t(_, "adapted-args"))) + assertFalse(check("-Xlint:_,-adapted-args")(t(_, "adapted-args"))) + assertFalse(check("-Xlint:-adapted-args,_")(t(_, "adapted-args"))) + assertTrue(check("-Xlint:-adapted-args,_,adapted-args")(t(_, "adapted-args"))) + } + + @Test def xLintDeprecatedAlias(): Unit = { + assertTrue(check("-Ywarn-adapted-args")(_.warnAdaptedArgs)) + assertTrue(check("-Xlint:_,-adapted-args", "-Ywarn-adapted-args")(_.warnAdaptedArgs)) + assertTrue(check("-Xlint:-adapted-args", "-Ywarn-adapted-args")(_.warnAdaptedArgs)) + assertTrue(check("-Ywarn-adapted-args", "-Xlint:-adapted-args,_")(_.warnAdaptedArgs)) + + assertFalse(check("-Ywarn-adapted-args:false")(_.warnAdaptedArgs)) + assertFalse(check("-Ywarn-adapted-args:false", "-Xlint:_")(_.warnAdaptedArgs)) + assertFalse(check("-Ywarn-adapted-args:false", "-Xlint:_,-adapted-args")(_.warnAdaptedArgs)) + assertTrue(check("-Ywarn-adapted-args:false", "-Xlint:_,adapted-args")(_.warnAdaptedArgs)) } } From 2b5ac5aa5fe46bd3eb3eba3de2eca68a09833703 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Wiejacha?= Date: Fri, 22 Aug 2014 09:15:01 +0200 Subject: [PATCH 516/826] SI-8810 scaladoc: fixed code block indentation normalization --- .../nsc/doc/base/CommentFactoryBase.scala | 50 +++---------------- test/scaladoc/resources/code-indent.scala | 6 +++ .../scaladoc/scalacheck/HtmlFactoryTest.scala | 7 +-- 3 files changed, 18 insertions(+), 45 deletions(-) diff --git a/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala b/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala index 19cc27b40b0d..a2d4327f8ba7 100755 --- a/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala +++ b/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala @@ -723,49 +723,15 @@ trait CommentFactoryBase { this: MemberLookupBase => */ def normalizeIndentation(_code: String): String = { - val code = _code.trim - var maxSkip = Integer.MAX_VALUE - var crtSkip = 0 - var wsArea = true - var index = 0 - var firstLine = true - var emptyLine = true - - while (index < code.length) { - code(index) match { - case ' ' => - if (wsArea) - crtSkip += 1 - case c => - wsArea = (c == '\n') - maxSkip = if (firstLine || emptyLine) maxSkip else if (maxSkip <= crtSkip) maxSkip else crtSkip - crtSkip = if (c == '\n') 0 else crtSkip - firstLine = if (c == '\n') false else firstLine - emptyLine = if (c == '\n') true else false - } - index += 1 - } + val code = _code.replaceAll("\\s+$", "").dropWhile(_ == '\n') // right-trim + remove all leading '\n' + val lines = code.split("\n") - if (maxSkip == 0) - code - else { - index = 0 - val builder = new StringBuilder - while (index < code.length) { - builder.append(code(index)) - if (code(index) == '\n') { - // we want to skip as many spaces are available, if there are less spaces (like on empty lines, do not - // over-consume them) - index += 1 - val limit = index + maxSkip - while ((index < code.length) && (code(index) == ' ') && index < limit) - index += 1 - } - else - index += 1 - } - builder.toString - } + // maxSkip - size of the longest common whitespace prefix of non-empty lines + val nonEmptyLines = lines.filter(_.trim.nonEmpty) + val maxSkip = if (nonEmptyLines.isEmpty) 0 else nonEmptyLines.map(line => line.prefixLength(_ == ' ')).min + + // remove common whitespace prefix + lines.map(line => if (line.trim.nonEmpty) line.substring(maxSkip) else line).mkString("\n") } def checkParaEnded(): Boolean = { diff --git a/test/scaladoc/resources/code-indent.scala b/test/scaladoc/resources/code-indent.scala index 88946ffc7f9c..2eee3352b451 100644 --- a/test/scaladoc/resources/code-indent.scala +++ b/test/scaladoc/resources/code-indent.scala @@ -20,6 +20,12 @@ * an alternative * the e l s e branch * }}} + * {{{ + * Trait example { + * Val x = a + * Val y = b + * } + * }}} * NB: Trailing spaces are necessary for this test! * {{{ * l1 diff --git a/test/scaladoc/scalacheck/HtmlFactoryTest.scala b/test/scaladoc/scalacheck/HtmlFactoryTest.scala index ef70e0bf218d..da0f253a37f8 100644 --- a/test/scaladoc/scalacheck/HtmlFactoryTest.scala +++ b/test/scaladoc/scalacheck/HtmlFactoryTest.scala @@ -659,6 +659,7 @@ object Test extends Properties("HtmlFactory") { s.contains("
        two lines, one useful
        ") && s.contains("
        line1\nline2\nline3\nline4
        ") && s.contains("
        a ragged example\na (condition)\n  the t h e n branch\nan alternative\n  the e l s e branch
        ") && + s.contains("
        Trait example {\n  Val x = a\n  Val y = b\n}
        ") && s.contains("
        l1\n\nl2\n\nl3\n\nl4\n\nl5
        ") } case _ => false @@ -683,7 +684,7 @@ object Test extends Properties("HtmlFactory") { oneAuthor match { case node: scala.xml.Node => { val s = node.toString - s.contains("
        Author:
        ") + s.contains("
        Author:
        ") && s.contains("

        The Only Author\n

        ") } case _ => false @@ -696,8 +697,8 @@ object Test extends Properties("HtmlFactory") { twoAuthors match { case node: scala.xml.Node => { val s = node.toString - s.contains("
        Authors:
        ") - s.contains("

        The First Author\n

        ") + s.contains("
        Authors:
        ") && + s.contains("

        The First Author

        ") && s.contains("

        The Second Author\n

        ") } case _ => false From d153ceeed133adfefe6c44a56f8ee502c1278e89 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Wed, 3 Sep 2014 10:39:22 +0200 Subject: [PATCH 517/826] SI-8113 allow a newline between a link target and title Parsing "[[http://foo.bar link title]]" stops at the first whitespace. This breaks pretty badly in: [[http://foo.bar link title]] It stops after "link", interprets what it parsed as a link to a member, obviously fails, and then just ouputs "title". It should at least return a proper error, or, even better, just allow a newline between the target and title. I went for the latter. --- .../nsc/doc/base/CommentFactoryBase.scala | 8 +++-- test/scaladoc/run/t8113.check | 1 + test/scaladoc/run/t8113.scala | 36 +++++++++++++++++++ 3 files changed, 43 insertions(+), 2 deletions(-) create mode 100644 test/scaladoc/run/t8113.check create mode 100644 test/scaladoc/run/t8113.scala diff --git a/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala b/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala index d5e2f9a2c4d5..6f8173903124 100755 --- a/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala +++ b/src/scaladoc/scala/tools/nsc/doc/base/CommentFactoryBase.scala @@ -681,10 +681,10 @@ trait CommentFactoryBase { this: MemberLookupBase => jump("[[") val parens = 2 + repeatJump('[') val stop = "]" * parens - val target = readUntil { check(stop) || check(" ") } + val target = readUntil { check(stop) || isWhitespaceOrNewLine(char) } val title = if (!check(stop)) Some({ - jump(" ") + jumpWhitespaceOrNewLine() inline(check(stop)) }) else None @@ -899,6 +899,8 @@ trait CommentFactoryBase { this: MemberLookupBase => def jumpWhitespace() = jumpUntil(!isWhitespace(char)) + def jumpWhitespaceOrNewLine() = jumpUntil(!isWhitespaceOrNewLine(char)) + /* READERS */ final def readUntil(c: Char): String = { @@ -938,5 +940,7 @@ trait CommentFactoryBase { this: MemberLookupBase => /* CHARS CLASSES */ def isWhitespace(c: Char) = c == ' ' || c == '\t' + + def isWhitespaceOrNewLine(c: Char) = isWhitespace(c) || c == '\n' } } diff --git a/test/scaladoc/run/t8113.check b/test/scaladoc/run/t8113.check new file mode 100644 index 000000000000..619c56180bb9 --- /dev/null +++ b/test/scaladoc/run/t8113.check @@ -0,0 +1 @@ +Done. diff --git a/test/scaladoc/run/t8113.scala b/test/scaladoc/run/t8113.scala new file mode 100644 index 000000000000..f006213ef299 --- /dev/null +++ b/test/scaladoc/run/t8113.scala @@ -0,0 +1,36 @@ +import scala.tools.nsc.doc.base._ +import scala.tools.nsc.doc.base.comment._ +import scala.tools.nsc.doc.model._ +import scala.tools.partest.ScaladocModelTest + +object Test extends ScaladocModelTest { + + override def code = """ + /** + * Check out [[http://www.scala-lang.org + * this great website]]! + */ + class Test + """ + + def scaladocSettings = "" + + def testModel(rootPackage: Package) = { + import access._ + + val test = rootPackage._class("Test") + + // find Link + def find(body: Any): Option[Link] = body match { + case l: Link => Some(l) + case s: Seq[_] => s.toList.map(find(_)).flatten.headOption + case p: Product => p.productIterator.toList.map(find(_)).flatten.headOption + case _ => None + } + + val link = find(test.comment.get.body).collect { case Link(ta, Text(ti)) => (ta, ti) } + assert(link.isDefined) + val expected = ("http://www.scala-lang.org", "this great website") + link.foreach {l => assert(l == expected, s"$l != $expected")} + } +} From e9a6fbb42f5214995d63dfee476c44b0564a0856 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Wed, 3 Sep 2014 14:13:53 +0200 Subject: [PATCH 518/826] SI-8786 disable part of test that's failing the jdk8 build --- test/files/jvm/varargs/VaClass.scala | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/test/files/jvm/varargs/VaClass.scala b/test/files/jvm/varargs/VaClass.scala index e94e8a625acd..d83e63ace1e3 100644 --- a/test/files/jvm/varargs/VaClass.scala +++ b/test/files/jvm/varargs/VaClass.scala @@ -9,5 +9,7 @@ class VaClass { @varargs def vs(a: Int, b: String*) = println(a + b.length) @varargs def vi(a: Int, b: Int*) = println(a + b.sum) @varargs def vt[T](a: Int, b: T*) = println(a + b.length) - @varargs def vt1[T](a: Int, b: T*): T = b.head + + // TODO remove type bound after fixing SI-8786, see also https://github.com/scala/scala/pull/3961 + @varargs def vt1[T <: String](a: Int, b: T*): T = b.head } From c9ec916f20c4f06a0aebe0a9929443c1c8b60c5c Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Wed, 20 Aug 2014 10:25:28 -0700 Subject: [PATCH 519/826] SI-8806 Add lower bound check to Any lint We already exclude the lint check for infer-any if Any is somewhere explicit. This commit adds lower bounds of type params to the somewheres. Motivated by: ``` scala> f"${42}" :8: warning: a type was inferred to be `Any`; this may indicate a programming error. f"${42}" ^ res0: String = 42 ``` --- src/compiler/scala/tools/nsc/typechecker/Infer.scala | 11 +++++++++-- test/files/neg/warn-inferred-any.check | 5 ++++- test/files/neg/warn-inferred-any.scala | 8 ++++++++ 3 files changed, 21 insertions(+), 3 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/Infer.scala b/src/compiler/scala/tools/nsc/typechecker/Infer.scala index a3f1da60ce94..c793632de4af 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Infer.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Infer.scala @@ -546,7 +546,14 @@ trait Infer extends Checkable { val targs = solvedTypes(tvars, tparams, tparams map varianceInTypes(formals), upper = false, lubDepth(formals) max lubDepth(argtpes)) // Can warn about inferring Any/AnyVal as long as they don't appear // explicitly anywhere amongst the formal, argument, result, or expected type. - def canWarnAboutAny = !(pt :: restpe :: formals ::: argtpes exists (t => (t contains AnyClass) || (t contains AnyValClass))) + // ...or lower bound of a type param, since they're asking for it. + def canWarnAboutAny = { + val loBounds = tparams map (_.info.bounds.lo) + val hasAny = pt :: restpe :: formals ::: argtpes ::: loBounds exists (t => + (t contains AnyClass) || (t contains AnyValClass) + ) + !hasAny + } def argumentPosition(idx: Int): Position = context.tree match { case x: ValOrDefDef => x.rhs match { case Apply(fn, args) if idx < args.size => args(idx).pos @@ -554,7 +561,7 @@ trait Infer extends Checkable { } case _ => context.tree.pos } - if (settings.warnInferAny.value && context.reportErrors && canWarnAboutAny) { + if (settings.warnInferAny && context.reportErrors && canWarnAboutAny) { foreachWithIndex(targs) ((targ, idx) => targ.typeSymbol match { case sym @ (AnyClass | AnyValClass) => diff --git a/test/files/neg/warn-inferred-any.check b/test/files/neg/warn-inferred-any.check index 4628033e55ab..8ad81d152957 100644 --- a/test/files/neg/warn-inferred-any.check +++ b/test/files/neg/warn-inferred-any.check @@ -7,6 +7,9 @@ warn-inferred-any.scala:16: warning: a type was inferred to be `AnyVal`; this ma warn-inferred-any.scala:17: warning: a type was inferred to be `AnyVal`; this may indicate a programming error. { 1l to 5l contains 5d } ^ +warn-inferred-any.scala:25: warning: a type was inferred to be `Any`; this may indicate a programming error. + def za = f(1, "one") + ^ error: No warnings can be incurred under -Xfatal-warnings. -three warnings found +four warnings found one error found diff --git a/test/files/neg/warn-inferred-any.scala b/test/files/neg/warn-inferred-any.scala index b853e6e5a81a..693c33e7be06 100644 --- a/test/files/neg/warn-inferred-any.scala +++ b/test/files/neg/warn-inferred-any.scala @@ -17,3 +17,11 @@ trait Ys[+A] { { 1l to 5l contains 5d } { 1l to 5l contains 5l } } + +trait Zs { + def f[A](a: A*) = 42 + def g[A >: Any](a: A*) = 42 // don't warn + + def za = f(1, "one") + def zu = g(1, "one") +} From 7655a70489f565a5a7a165f893b4a1e44c3cb2b8 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Mon, 25 Aug 2014 10:15:04 -0700 Subject: [PATCH 520/826] Use Enumeration for MultiChoiceSetting This is pretty easy, since a ValueSet is a BitSet. When the setting is updated, recompute the current set of values, which is cheap and succinct. Checking a flag is also easy and fast. Choices in MultiChoiceSettings may enable other choices. --- .../scala/tools/nsc/CompilerCommand.scala | 2 +- src/compiler/scala/tools/nsc/MainBench.scala | 2 +- .../tools/nsc/settings/AbsScalaSettings.scala | 24 +- .../tools/nsc/settings/MutableSettings.scala | 241 +++++++++++------- .../tools/nsc/settings/ScalaSettings.scala | 39 ++- .../scala/tools/nsc/settings/Warnings.scala | 100 ++++---- .../scala/tools/nsc/util/StatisticsInfo.scala | 2 +- .../tools/nsc/settings/SettingsTest.scala | 46 +++- 8 files changed, 288 insertions(+), 168 deletions(-) diff --git a/src/compiler/scala/tools/nsc/CompilerCommand.scala b/src/compiler/scala/tools/nsc/CompilerCommand.scala index 3ded4563789d..9b8e9fa3304f 100644 --- a/src/compiler/scala/tools/nsc/CompilerCommand.scala +++ b/src/compiler/scala/tools/nsc/CompilerCommand.scala @@ -107,7 +107,7 @@ class CompilerCommand(arguments: List[String], val settings: Settings) { else { val sb = new StringBuilder allSettings foreach { - case s: MultiChoiceSetting if s.isHelping => sb append s.help + case s: MultiChoiceSetting[_] if s.isHelping => sb append s.help case _ => } sb.toString diff --git a/src/compiler/scala/tools/nsc/MainBench.scala b/src/compiler/scala/tools/nsc/MainBench.scala index eb56c8a2306f..f01de0cbe118 100644 --- a/src/compiler/scala/tools/nsc/MainBench.scala +++ b/src/compiler/scala/tools/nsc/MainBench.scala @@ -24,7 +24,7 @@ object MainBench extends Driver with EvalLoop { var start = System.nanoTime() for (i <- 0 until NIter) { if (i == NIter-1) { - theCompiler.settings.YstatisticsPhases.value = theCompiler.settings.YstatisticsPhases.default.get + theCompiler.settings.Ystatistics.default.get foreach theCompiler.settings.Ystatistics.add Statistics.enabled = true } process(args) diff --git a/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala index cd2cb183b385..6b339b2a6da4 100644 --- a/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/AbsScalaSettings.scala @@ -7,20 +7,24 @@ package scala package tools.nsc package settings +import scala.language.higherKinds + trait AbsScalaSettings { self: AbsSettings => + type MultiChoiceEnumeration <: Enumeration + type Setting <: AbsSetting - type BooleanSetting <: Setting { type T = Boolean } - type ChoiceSetting <: Setting { type T = String } - type IntSetting <: Setting { type T = Int } - type MultiStringSetting <: Setting { type T = List[String] } - type MultiChoiceSetting <: Setting { type T = List[String] } - type PathSetting <: Setting { type T = String } - type PhasesSetting <: Setting { type T = List[String] } - type StringSetting <: Setting { type T = String } - type PrefixSetting <: Setting { type T = List[String] } + type BooleanSetting <: Setting { type T = Boolean } + type ChoiceSetting <: Setting { type T = String } + type IntSetting <: Setting { type T = Int } + type MultiStringSetting <: Setting { type T = List[String] } + type MultiChoiceSetting[E <: MultiChoiceEnumeration] <: Setting { type T <: E#ValueSet } + type PathSetting <: Setting { type T = String } + type PhasesSetting <: Setting { type T = List[String] } + type StringSetting <: Setting { type T = String } + type PrefixSetting <: Setting { type T = List[String] } type OutputDirs type OutputSetting <: Setting @@ -29,7 +33,7 @@ trait AbsScalaSettings { def ChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: String): ChoiceSetting def IntSetting(name: String, descr: String, default: Int, range: Option[(Int, Int)], parser: String => Option[Int]): IntSetting def MultiStringSetting(name: String, helpArg: String, descr: String): MultiStringSetting - def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], descriptions: List[String], default: Option[List[String]]): MultiChoiceSetting + def MultiChoiceSetting[E <: MultiChoiceEnumeration](name: String, helpArg: String, descr: String, domain: E, default: Option[List[String]]): MultiChoiceSetting[E] def OutputSetting(outputDirs: OutputDirs, default: String): OutputSetting def PathSetting(name: String, descr: String, default: String): PathSetting def PhasesSetting(name: String, descr: String, default: String): PhasesSetting diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala index b9b9257d637d..78d70610666c 100644 --- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala @@ -212,8 +212,8 @@ class MutableSettings(val errorFn: String => Unit) def IntSetting(name: String, descr: String, default: Int, range: Option[(Int, Int)], parser: String => Option[Int]) = add(new IntSetting(name, descr, default, range, parser)) def MultiStringSetting(name: String, arg: String, descr: String) = add(new MultiStringSetting(name, arg, descr)) - def MultiChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], descriptions: List[String], default: Option[List[String]] = None) = - add(new MultiChoiceSetting(name, helpArg, descr, choices, descriptions, default)) + def MultiChoiceSetting[E <: MultiChoiceEnumeration](name: String, helpArg: String, descr: String, domain: E, default: Option[List[String]] = None) = + add(new MultiChoiceSetting[E](name, helpArg, descr, domain, default)) def OutputSetting(outputDirs: OutputDirs, default: String) = add(new OutputSetting(outputDirs, default)) def PhasesSetting(name: String, descr: String, default: String = "") = add(new PhasesSetting(name, descr, default)) def StringSetting(name: String, arg: String, descr: String, default: String) = add(new StringSetting(name, arg, descr, default)) @@ -366,7 +366,7 @@ class MutableSettings(val errorFn: String => Unit) def withDeprecationMessage(msg: String): this.type = { _deprecationMessage = Some(msg) ; this } } - /** A setting represented by an integer */ + /** A setting represented by an integer. */ class IntSetting private[nsc]( name: String, descr: String, @@ -553,122 +553,179 @@ class MutableSettings(val errorFn: String => Unit) } /** - * A setting that receives multiple values. There are two modes - * - choosing: the setting has a list of allowed chioces. - * - These choices can be positive or negative, for exmample "-option:positive,-negative" - * - If an option is both enabled positively and negatively, the positive wins - * - The choice "_" enables all choices that have not explicitly been disabled + * Each [[MultiChoiceSetting]] takes a MultiChoiceEnumeration as domain. The enumartion may + * use the Choice class to define values, or simply use the default `Value` constructor: * - * - !choosing: the setting accumulates all arguments. + * object SettingDomain extends MultiChoiceEnumeration { val arg1, arg2 = Value } * - * Arguments can be provided in colonated or non-colonated mode, i.e. "-option a b" or - * "-option:a,b". Note that arguments starting with a "-" can only be provided in colonated mode, - * otherwise they are interpreted as a new option. + * Or * - * In colonated and choosing mode, the setting stops consuming arguments at the first non-choice, - * i.e. "-option a b c" only consumes "a" and "b" if "c" is not a valid choice. + * object SettingDomain extends MultiChoiceEnumeration { + * val arg1 = Choice("arg1", "help") + * val arg2 = Choice("arg2", "help") + * } * - * @param name command-line setting name, eg "-Xlint" - * @param arg description of the kind of arguments that need to be passed, eg "warning" - * @param descr description of the setting - * @param choices a list of allowed arguments. if empty, accepts any argument that doesn't start with "-" - * @param descriptions a description for each choice (for the help message), may be empty if no descriptions are necessary - * @param default default arguments, if none are provided + * Choices with a non-empty `expandsTo` enable other options. Note that expanding choices are + * not present in the multiChoiceSetting.value set, only their expansion. */ - class MultiChoiceSetting private[nsc]( + abstract class MultiChoiceEnumeration extends Enumeration { + case class Choice(name: String, help: String = "", expandsTo: List[Choice] = Nil) extends Val(name) + } + + /** A Setting that collects string-valued settings from an enumerated domain. + * - These choices can be turned on or off: "-option:on,-off" + * - If an option is set both on and off, then the option is on + * - The choice "_" enables all choices that have not been explicitly disabled + * + * Arguments can be provided in colonated or non-colonated mode, i.e. "-option a b" or + * "-option:a,b". Note that arguments starting with a "-" can only be provided in colonated mode, + * otherwise they are interpreted as a new option. + * + * In non-colonated mode, the setting stops consuming arguments at the first non-choice, + * i.e. "-option a b c" only consumes "a" and "b" if "c" is not a valid choice. + * + * @param name command-line setting name, eg "-Xlint" + * @param helpArg help description for the kind of arguments it takes, eg "warning" + * @param descr description of the setting + * @param domain enumeration of choices implementing MultiChoice, or the string value is + * taken for the name + * @param default If Some(args), the default options if none are provided. If None, an + * error is printed if there are no arguments. + */ + class MultiChoiceSetting[E <: MultiChoiceEnumeration] private[nsc]( name: String, - arg: String, + helpArg: String, descr: String, - override val choices: List[String], - val descriptions: List[String], + val domain: E, val default: Option[List[String]] - ) extends MultiStringSetting(name, s"_,$arg,-$arg", s"$descr: `_' for all, `$name:help' to list") { + ) extends Setting(name, s"$descr: `_' for all, `$name:help' to list") with Clearable { + + withHelpSyntax(s"$name:<_,$helpArg,-$helpArg>") - private def badChoice(s: String, n: String) = errorFn(s"'$s' is not a valid choice for '$name'") - private def choosing = choices.nonEmpty // choices are known, error on invalid args - private def isChoice(s: String) = (s == "_") || (choices contains (s stripPrefix "-")) + object ChoiceOrVal { + def unapply(a: Any): Option[(String, String, List[domain.Choice])] = a match { + case c: domain.Choice => Some((c.name, c.help, c.expandsTo)) + case v: domain.Value => Some((v.toString, "", Nil)) + case _ => None + } + } - private var sawHelp = false - private var sawAll = false + type T = domain.ValueSet + protected var v: T = domain.ValueSet.empty + + // Explicitly enabled or disabled. Yeas may contain expanding options, nays may not. + private var yeas = domain.ValueSet.empty + private var nays = domain.ValueSet.empty + + // Asked for help + private var sawHelp = false + // Wildcard _ encountered + private var sawAll = false + + private def badChoice(s: String) = errorFn(s"'$s' is not a valid choice for '$name'") + private def isChoice(s: String) = (s == "_") || (choices contains pos(s)) private def pos(s: String) = s stripPrefix "-" + private def isPos(s: String) = !(s startsWith "-") - /** - * This override takes care of including all possible choices in case the "_" argument was - * passed. It adds the choices that have not explicitly been enabled or disabled. This ensures - * that "this contains x" is consistent with "this.value contains x". - * - * The explicitly enabled / disabled options are stored in the underlying value [[v]], disabled - * ones are stored as "-arg". - * - * The fact that value and v are not the same leaks in some cases. For example, you should never - * use "value += arg", because that expands to "value = value + arg". In case sawAll is true, - * this would propagate all choices enabled by sawAll into the underlying v. - * - * Instead of "value += arg", you should use "this.add(arg)". I haven't found a good way to - * enforce that. - */ - override def value: List[String] = { - if (!sawAll) v - else { - // add only those choices which have not explicitly been enabled or disabled. - val fromAll = choices.filterNot(c => v.exists(pos(_) == c)) - v ++ fromAll + override val choices: List[String] = domain.values.toList map { + case ChoiceOrVal(name, _, _) => name + } + + def descriptions: List[String] = domain.values.toList map { + case ChoiceOrVal(_, "", x :: xs) => "Enables the options "+ (x :: xs).map(_.name).mkString(", ") + case ChoiceOrVal(_, descr, _) => descr + case _ => "" + } + + /** (Re)compute from current yeas, nays, wildcard status. */ + def compute() = { + def nonExpanding(vs: domain.ValueSet) = vs filter { + case ChoiceOrVal(_, _, others) => others.isEmpty + } + + /** + * Expand an option, if necessary recursively. Expanding options are not included in the + * result (consistent with "_", which is not in the values either). Explicitly excluded + * options (in nays) are not added. + * + * Note: by precondition, options in nays are not expanding, they can only be leaves. + */ + def expand(vs: domain.ValueSet): domain.ValueSet = vs flatMap { + // expand + case c @ ChoiceOrVal(_, _, others) if others.nonEmpty => expand(domain.ValueSet(others: _*)) + case c @ ChoiceOrVal(_, _, _) if !nays(c) => domain.ValueSet(c) + case _ => domain.ValueSet.empty } + val expandedYeas = expand(yeas) + + + // we include everything, except those explicitly disabled. + val expandedAll = if (sawAll) nonExpanding(domain.values) &~ nays + else domain.ValueSet.empty + + value = nonExpanding(yeas) | expandedYeas | expandedAll } - /** - * Add an argument to the list of values. - */ - def add(arg: String) = { - if (choosing && !isChoice(arg)) badChoice(arg, name) - if (arg == "_") { + /** Add a named choice to the multichoice value. */ + def add(arg: String) = arg match { + case _ if !isChoice(arg) => + badChoice(arg) + case "_" => sawAll = true - value = v // the value_= setter has side effects, make sure to execute them. - } else { - val posArg = pos(arg) - if (arg == posArg) { - // positive overrides existing negative. so we filter existing (pos or neg), and add the arg - value = v.filterNot(pos(_) == posArg) :+ arg - } else { - // negative arg is only added if the arg doesn't exist yet (pos or neg) - if (!v.exists(pos(_) == posArg)) value = v :+ arg // not value += arg, see doc of the "value" getter + compute() + case _ if isPos(arg) => + yeas += domain withName arg + compute() + case _ => + val choice = domain withName pos(arg) + choice match { + case ChoiceOrVal(_, _, _ :: _) => errorFn(s"'${pos(arg)}' cannot be negated, it enables other arguments") + case _ => } - } + nays += choice + compute() } - override protected def tts(args: List[String], halting: Boolean) = { + def tryToSet(args: List[String]) = tryToSetArgs(args, halting = true) + override def tryToSetColon(args: List[String]) = tryToSetArgs(args, halting = false) + override def tryToSetFromPropertyValue(s: String) = tryToSet(s.trim.split(',').toList) // used from ide + + /** Try to set args, handling "help" and default. + * The "halting" parameter means args were "-option a b c -else" so halt + * on "-else" or other non-choice. Otherwise, args were "-option:a,b,c,d", + * so process all and report non-choices as errors. + * @param args args to process + * @param halting stop on non-arg + */ + private def tryToSetArgs(args: List[String], halting: Boolean) = { val added = collection.mutable.ListBuffer.empty[String] def tryArg(arg: String) = arg match { - case "help" if choosing => sawHelp = true - case s if !choosing || isChoice(s) => added += s // this case also adds "_" - case s => badChoice(s, name) + case "help" => sawHelp = true + case s if isChoice(s) => added += s // this case also adds "_" + case s => badChoice(s) } - - // if "halting" is true, the args were not specified as , separated after a : - // but space separated after a space. we stop consuming args when seeing - // - an arg starting with a "-", that is a new option - // - if the choices are known (choosing), on the first non-choice - def stoppingAt(arg: String) = (arg startsWith "-") || (choosing && !isChoice(arg)) - def loop(args: List[String]): List[String] = args match { - case arg :: _ if halting && stoppingAt(arg) => args - case arg :: rest => tryArg(arg) ; loop(rest) - case Nil => Nil + case arg :: _ if halting && (!isPos(arg) || !isChoice(arg)) => args + case arg :: rest => tryArg(arg) ; loop(rest) + case Nil => Nil } - val rest = loop(args) - if (rest.size == args.size) default match { // if no arg consumed, use defaults or error + + // if no arg consumed, use defaults or error; otherwise, add what they added + if (rest.size == args.size) default match { case Some(defaults) => defaults foreach add case None => errorFn(s"'$name' requires an option. See '$name:help'.") } else { - added.toList foreach add + added foreach add } Some(rest) } + def contains(choice: domain.Value): Boolean = value contains choice + def isHelping: Boolean = sawHelp def help: String = { @@ -678,6 +735,16 @@ class MutableSettings(val errorFn: String => Unit) case (arg, descr) => formatStr.format(arg, descr) } mkString (f"$descr%n", f"%n", "") } + + def clear(): Unit = { + v = domain.ValueSet.empty + yeas = domain.ValueSet.empty + nays = domain.ValueSet.empty + sawAll = false + sawHelp = false + } + def unparse: List[String] = value.toList map (s => s"$name:$s") + def contains(s: String) = value contains (domain withName s) } /** A setting that accumulates all strings supplied to it, @@ -693,15 +760,15 @@ class MutableSettings(val errorFn: String => Unit) def appendToValue(str: String) = value ++= List(str) // try to set. halting means halt at first non-arg - protected def tts(args: List[String], halting: Boolean) = { + protected def tryToSetArgs(args: List[String], halting: Boolean) = { def loop(args: List[String]): List[String] = args match { case arg :: rest => if (halting && (arg startsWith "-")) args else { appendToValue(arg) ; loop(rest) } case Nil => Nil } Some(loop(args)) } - def tryToSet(args: List[String]) = tts(args, halting = true) - override def tryToSetColon(args: List[String]) = tts(args, halting = false) + def tryToSet(args: List[String]) = tryToSetArgs(args, halting = true) + override def tryToSetColon(args: List[String]) = tryToSetArgs(args, halting = false) override def tryToSetFromPropertyValue(s: String) = tryToSet(s.trim.split(',').toList) // used from ide def clear(): Unit = (v = Nil) diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala index 1609aa5ff7b2..91b03869e5a6 100644 --- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala @@ -45,7 +45,7 @@ trait ScalaSettings extends AbsScalaSettings def infoSettings = List[Setting](version, help, Xhelp, Yhelp, showPlugins, showPhases, genPhaseGraph) /** Any -multichoice:help? Nicer if any option could report that it had help to offer. */ - private def multihelp = allSettings exists { case s: MultiChoiceSetting => s.isHelping case _ => false } + private def multihelp = allSettings exists { case s: MultiChoiceSetting[_] => s.isHelping case _ => false } /** Is an info setting set? */ def isInfo = (infoSettings exists (_.isSetByUser)) || multihelp @@ -69,23 +69,22 @@ trait ScalaSettings extends AbsScalaSettings // Would be nice to build this dynamically from scala.languageFeature. // The two requirements: delay error checking until you have symbols, and let compiler command build option-specific help. + object languageFeatures extends MultiChoiceEnumeration { + val dynamics = Choice("dynamics", "Allow direct or indirect subclasses of scala.Dynamic") + val postfixOps = Choice("postfixOps", "Allow postfix operator notation, such as `1 to 10 toList'") + val reflectiveCalls = Choice("reflectiveCalls", "Allow reflective access to members of structural types") + val implicitConversions = Choice("implicitConversions", "Allow definition of implicit functions called views") + val higherKinds = Choice("higherKinds", "Allow higher-kinded types") + val existentials = Choice("existentials", "Existential types (besides wildcard types) can be written and inferred") + val macros = Choice("experimental.macros", "Allow macro defintion (besides implementation and application)") + } val language = { - val features = List( - "dynamics" -> "Allow direct or indirect subclasses of scala.Dynamic", - "postfixOps" -> "Allow postfix operator notation, such as `1 to 10 toList'", - "reflectiveCalls" -> "Allow reflective access to members of structural types", - "implicitConversions" -> "Allow definition of implicit functions called views", - "higherKinds" -> "Allow higher-kinded types", // "Ask Adriaan, but if you have to ask..." - "existentials" -> "Existential types (besides wildcard types) can be written and inferred", - "experimental.macros" -> "Allow macro defintion (besides implementation and application)" - ) val description = "Enable or disable language features" MultiChoiceSetting( name = "-language", helpArg = "feature", descr = description, - choices = features map (_._1), - descriptions = features map (_._2) + domain = languageFeatures ) } @@ -212,19 +211,19 @@ trait ScalaSettings extends AbsScalaSettings private def removalIn212 = "This flag is scheduled for removal in 2.12. If you have a case where you need this flag then please report a bug." - val YstatisticsPhases = { - val phases = List("parser", "typer", "patmat", "erasure", "cleanup") + object YstatisticsPhases extends MultiChoiceEnumeration { val parser, typer, patmat, erasure, cleanup = Value } + val Ystatistics = { val description = "Print compiler statistics for specific phases" MultiChoiceSetting( - name = "-Ystatistics", + name = "-Ystatistics", helpArg = "phase", - descr = description, - choices = phases, - descriptions = Nil, - default = Some(List("_"))) withPostSetHook { _ => scala.reflect.internal.util.Statistics.enabled = true } + descr = description, + domain = YstatisticsPhases, + default = Some(List("_")) + ) withPostSetHook { _ => scala.reflect.internal.util.Statistics.enabled = true } } - def YstatisticsEnabled = YstatisticsPhases.value.nonEmpty + def YstatisticsEnabled = Ystatistics.value.nonEmpty /** Area-specific debug output. */ diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala index 771543ec7788..574825874d51 100644 --- a/src/compiler/scala/tools/nsc/settings/Warnings.scala +++ b/src/compiler/scala/tools/nsc/settings/Warnings.scala @@ -38,21 +38,45 @@ trait Warnings { // Lint warnings - def warnAdaptedArgs = lint contains "adapted-args" - def warnNullaryUnit = lint contains "nullary-unit" - def warnInaccessible = lint contains "inaccessible" - def warnNullaryOverride = lint contains "nullary-override" - def warnInferAny = lint contains "infer-any" - def warnMissingInterpolator = lint contains "missing-interpolator" - def warnDocDetached = lint contains "doc-detached" - def warnPrivateShadow = lint contains "private-shadow" - def warnTypeParameterShadow = lint contains "type-parameter-shadow" - def warnPolyImplicitOverload = lint contains "poly-implicit-overload" - def warnOptionImplicit = lint contains "option-implicit" - def warnDelayedInit = lint contains "delayedinit-select" - def warnByNameRightAssociative = lint contains "by-name-right-associative" - def warnPackageObjectClasses = lint contains "package-object-classes" - def warnUnsoundMatch = lint contains "unsound-match" + object LintWarnings extends MultiChoiceEnumeration { + class LintWarning(name: String, help: String, val yAliased: Boolean) extends Choice(name, help) + def LintWarning(name: String, help: String, yAliased: Boolean = false) = new LintWarning(name, help, yAliased) + + val AdaptedArgs = LintWarning("adapted-args", "Warn if an argument list is modified to match the receiver.", true) + val NullaryUnit = LintWarning("nullary-unit", "Warn when nullary methods return Unit.", true) + val Inaccessible = LintWarning("inaccessible", "Warn about inaccessible types in method signatures.", true) + val NullaryOverride = LintWarning("nullary-override", "Warn when non-nullary `def f()' overrides nullary `def f'.", true) + val InferAny = LintWarning("infer-any", "Warn when a type argument is inferred to be `Any`.", true) + val MissingInterpolator = LintWarning("missing-interpolator", "A string literal appears to be missing an interpolator id.") + val DocDetached = LintWarning("doc-detached", "A ScalaDoc comment appears to be detached from its element.") + val PrivateShadow = LintWarning("private-shadow", "A private field (or class parameter) shadows a superclass field.") + val TypeParameterShadow = LintWarning("type-parameter-shadow", "A local type parameter shadows a type already in scope.") + val PolyImplicitOverload = LintWarning("poly-implicit-overload", "Parameterized overloaded implicit methods are not visible as view bounds.") + val OptionImplicit = LintWarning("option-implicit", "Option.apply used implicit view.") + val DelayedInitSelect = LintWarning("delayedinit-select", "Selecting member of DelayedInit") + val ByNameRightAssociative = LintWarning("by-name-right-associative", "By-name parameter of right associative operator.") + val PackageObjectClasses = LintWarning("package-object-classes", "Class or object defined in package object.") + val UnsoundMatch = LintWarning("unsound-match", "Pattern match may not be typesafe.") + + def allWarnings = values.toSeq.asInstanceOf[Seq[LintWarning]] + } + import LintWarnings._ + + def warnAdaptedArgs = lint contains AdaptedArgs + def warnNullaryUnit = lint contains NullaryUnit + def warnInaccessible = lint contains Inaccessible + def warnNullaryOverride = lint contains NullaryOverride + def warnInferAny = lint contains InferAny + def warnMissingInterpolator = lint contains MissingInterpolator + def warnDocDetached = lint contains DocDetached + def warnPrivateShadow = lint contains PrivateShadow + def warnTypeParameterShadow = lint contains TypeParameterShadow + def warnPolyImplicitOverload = lint contains PolyImplicitOverload + def warnOptionImplicit = lint contains OptionImplicit + def warnDelayedInit = lint contains DelayedInitSelect + def warnByNameRightAssociative = lint contains ByNameRightAssociative + def warnPackageObjectClasses = lint contains PackageObjectClasses + def warnUnsoundMatch = lint contains UnsoundMatch // Lint warnings that are currently -Y, but deprecated in that usage @deprecated("Use warnAdaptedArgs", since="2.11.2") @@ -67,41 +91,23 @@ trait Warnings { def YwarnInferAny = warnInferAny // The Xlint warning group. - val lint: MultiChoiceSetting = { - val description = "Enable or disable specific warnings" - - val choices = List( - ("adapted-args", "Warn if an argument list is modified to match the receiver.", true), - ("nullary-unit", "Warn when nullary methods return Unit.", true), - ("inaccessible", "Warn about inaccessible types in method signatures.", true), - ("nullary-override", "Warn when non-nullary `def f()' overrides nullary `def f'.", true), - ("infer-any", "Warn when a type argument is inferred to be `Any`.", true), - ("missing-interpolator", "A string literal appears to be missing an interpolator id.", false), - ("doc-detached", "A ScalaDoc comment appears to be detached from its element.", false), - ("private-shadow", "A private field (or class parameter) shadows a superclass field.", false), - ("type-parameter-shadow", "A local type parameter shadows a type already in scope.", false), - ("poly-implicit-overload", "Parameterized overloaded implicit methods are not visible as view bounds.", false), - ("option-implicit", "Option.apply used implicit view.", false), - ("delayedinit-select", "Selecting member of DelayedInit", false), - ("by-name-right-associative", "By-name parameter of right associative operator.", false), - ("package-object-classes", "Class or object defined in package object.", false), - ("unsound-match", "Pattern match may not be typesafe.", false) - ).sorted - - for (c <- choices.filter(_._3)) { - BooleanSetting("-Ywarn-"+ c._1, c._2) withPostSetHook { s => - if (s) lint.add(c._1) - else lint.add("-" + c._1) - } // withDeprecationMessage s"Enable -Xlint:${c._1}" + val lint: MultiChoiceSetting[LintWarnings.type] = { + import LintWarnings._ + + allWarnings.sortBy(_.name) foreach { + case l: LintWarning if l.yAliased => + BooleanSetting(s"-Ywarn-${l.name}", {l.help}) withPostSetHook { s => + lint.add(if (s) l.name else s"-${l.name}") + } // withDeprecationMessage s"Enable -Xlint:${c._1}" + case _ => } MultiChoiceSetting( - name = "-Xlint", - helpArg = "warning", - descr = description, - choices = choices map (_._1), - descriptions = choices map (_._2), - default = Some(List("_")) + name = "-Xlint", + helpArg = "warning", + descr = "Enable or disable specific warnings", + domain = LintWarnings, + default = Some(List("_")) ) } diff --git a/src/compiler/scala/tools/nsc/util/StatisticsInfo.scala b/src/compiler/scala/tools/nsc/util/StatisticsInfo.scala index a5d579dc37a5..be245347a89d 100644 --- a/src/compiler/scala/tools/nsc/util/StatisticsInfo.scala +++ b/src/compiler/scala/tools/nsc/util/StatisticsInfo.scala @@ -17,7 +17,7 @@ abstract class StatisticsInfo { val retainedCount = Statistics.newCounter("#retained tree nodes") val retainedByType = Statistics.newByClass("#retained tree nodes by type")(Statistics.newCounter("")) - def print(phase: Phase) = if (settings.YstatisticsPhases contains phase.name) { + def print(phase: Phase) = if (settings.Ystatistics contains phase.name) { inform("*** Cumulative statistics at phase " + phase) retainedCount.value = 0 for (c <- retainedByType.keys) diff --git a/test/junit/scala/tools/nsc/settings/SettingsTest.scala b/test/junit/scala/tools/nsc/settings/SettingsTest.scala index a0e015be32d7..0b8029326e69 100644 --- a/test/junit/scala/tools/nsc/settings/SettingsTest.scala +++ b/test/junit/scala/tools/nsc/settings/SettingsTest.scala @@ -96,7 +96,7 @@ class SettingsTest { // make sure that lint.contains and lint.value.contains are consistent def t(s: MutableSettings, v: String) = { val r = s.lint.contains(v) - assertSame(r, s.lint.value.contains(v)) + assertSame(r, s.lint.value.contains((s.LintWarnings withName v).asInstanceOf[s.lint.domain.Value])) r } @@ -118,4 +118,48 @@ class SettingsTest { assertFalse(check("-Ywarn-adapted-args:false", "-Xlint:_,-adapted-args")(_.warnAdaptedArgs)) assertTrue(check("-Ywarn-adapted-args:false", "-Xlint:_,adapted-args")(_.warnAdaptedArgs)) } + + @Test def expandingMultichoice(): Unit = { + val s = new MutableSettings(msg => throw new IllegalArgumentException(msg)) + object mChoices extends s.MultiChoiceEnumeration { + val a = Choice("a") + val b = Choice("b") + val c = Choice("c") + val d = Choice("d") + + val ab = Choice("ab", expandsTo = List(a, b)) + val ac = Choice("ac", expandsTo = List(a, c)) + val uber = Choice("uber", expandsTo = List(ab, d)) + } + val m = s.MultiChoiceSetting("-m", "args", "magic sauce", mChoices, Some(List("ac"))) + + def check(args: String*)(t: s.MultiChoiceSetting[mChoices.type] => Boolean): Boolean = { + m.clear() + val (ok, rest) = s.processArguments(args.toList, processAll = true) + assert(rest.isEmpty) + t(m) + } + + import mChoices._ + + assertTrue(check("-m")(_.value == Set(a,c))) + assertTrue(check("-m:a,-b,c")(_.value == Set(a,c))) + + // expanding options don't end up in the value set, only the terminal ones + assertTrue(check("-m:ab,ac")(_.value == Set(a,b,c))) + assertTrue(check("-m:_")(_.value == Set(a,b,c,d))) + assertTrue(check("-m:uber,ac")(_.value == Set(a,b,c,d))) // recursive expansion of uber + + // explicit nays + assertTrue(check("-m:_,-b")(_.value == Set(a,c,d))) + assertTrue(check("-m:b,_,-b")(_.value == Set(a,b,c,d))) + assertTrue(check("-m:ac,-c")(_.value == Set(a))) + assertTrue(check("-m:ac,-a,-c")(_.value == Set())) + assertTrue(check("-m:-d,ac")(_.value == Set(a,c))) + assertTrue(check("-m:-b,ac,uber")(_.value == Set(a,c,d))) + + assertThrows[IllegalArgumentException](check("-m:-_")(_ => true), _ contains "'-_' is not a valid choice") + assertThrows[IllegalArgumentException](check("-m:a,b,-ab")(_ => true), _ contains "'ab' cannot be negated") + assertThrows[IllegalArgumentException](check("-m:a,ac,-uber,uber")(_ => true), _ contains "'uber' cannot be negated") + } } From f3d97117bbd2cca9d0cb7d58eb5a62429cfe5147 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Fri, 16 May 2014 23:46:07 +0300 Subject: [PATCH 521/826] Prefer scala.Serializable to j.io.Serializable The former extends the latter, and exists as a platorm agnostic serialization marker trait. It is of less value now that we have jettisoned the MSIL backend, but while it still exists we ought ought to use it. I achieved this by replacing wildcard import of `java.io._` with selective imports, leaving `Serializable` to bind to `scala.Serializable`. --- src/library/scala/collection/immutable/List.scala | 4 ++-- src/library/scala/collection/immutable/PagedSeq.scala | 2 +- src/library/scala/collection/mutable/ListBuffer.scala | 2 +- test/files/run/lub-visibility.check | 2 +- test/files/run/t2251b.check | 4 ++-- 5 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/library/scala/collection/immutable/List.scala b/src/library/scala/collection/immutable/List.scala index aa9dec276122..a8f114961578 100644 --- a/src/library/scala/collection/immutable/List.scala +++ b/src/library/scala/collection/immutable/List.scala @@ -13,7 +13,7 @@ package immutable import generic._ import mutable.{Builder, ListBuffer} import scala.annotation.tailrec -import java.io._ +import java.io.{ObjectOutputStream, ObjectInputStream} /** A class for immutable linked lists representing ordered collections * of elements of type. @@ -85,7 +85,7 @@ sealed abstract class List[+A] extends AbstractSeq[A] with Product with GenericTraversableTemplate[A, List] with LinearSeqOptimized[A, List[A]] - with Serializable { + with scala.Serializable { override def companion: GenericCompanion[List] = List import scala.collection.{Iterable, Traversable, Seq, IndexedSeq} diff --git a/src/library/scala/collection/immutable/PagedSeq.scala b/src/library/scala/collection/immutable/PagedSeq.scala index 3a64820be694..fb9f6703a964 100644 --- a/src/library/scala/collection/immutable/PagedSeq.scala +++ b/src/library/scala/collection/immutable/PagedSeq.scala @@ -12,7 +12,7 @@ package scala package collection package immutable -import java.io._ +import java.io.{File, FileReader, Reader} import scala.util.matching.Regex import scala.reflect.ClassTag diff --git a/src/library/scala/collection/mutable/ListBuffer.scala b/src/library/scala/collection/mutable/ListBuffer.scala index 5e838d0d88bc..d6a4d9213988 100644 --- a/src/library/scala/collection/mutable/ListBuffer.scala +++ b/src/library/scala/collection/mutable/ListBuffer.scala @@ -12,7 +12,7 @@ package mutable import generic._ import immutable.{List, Nil, ::} -import java.io._ +import java.io.{ObjectOutputStream, ObjectInputStream} import scala.annotation.migration /** A `Buffer` implementation back up by a list. It provides constant time diff --git a/test/files/run/lub-visibility.check b/test/files/run/lub-visibility.check index 70734966f0aa..135cb3cb767e 100644 --- a/test/files/run/lub-visibility.check +++ b/test/files/run/lub-visibility.check @@ -6,6 +6,6 @@ scala> // should infer List[scala.collection.immutable.Seq[Nothing]] scala> // but reverted that for SI-5534. scala> val x = List(List(), Vector()) -x: List[scala.collection.immutable.Seq[Nothing] with scala.collection.AbstractSeq[Nothing] with java.io.Serializable] = List(List(), Vector()) +x: List[scala.collection.immutable.Seq[Nothing] with scala.collection.AbstractSeq[Nothing] with Serializable] = List(List(), Vector()) scala> :quit diff --git a/test/files/run/t2251b.check b/test/files/run/t2251b.check index 4231fc6ea680..b60698d6055e 100644 --- a/test/files/run/t2251b.check +++ b/test/files/run/t2251b.check @@ -1,4 +1,4 @@ -TypeTag[List[scala.collection.immutable.LinearSeq[B[_ >: D with C <: B[_ >: D with C <: A]]] with scala.collection.AbstractSeq[B[_ >: D with C <: B[_ >: D with C <: A]]] with java.io.Serializable]] +TypeTag[List[scala.collection.immutable.LinearSeq[B[_ >: D with C <: B[_ >: D with C <: A]]] with scala.collection.AbstractSeq[B[_ >: D with C <: B[_ >: D with C <: A]]] with Serializable]] TypeTag[List[scala.collection.immutable.Iterable[B[_ >: F with E with D with C <: B[_ >: F with E with D with C <: A]]] with F with Int => Any]] TypeTag[List[scala.collection.immutable.Seq[B[_ >: D with C <: B[_ >: D with C <: A]]] with scala.collection.AbstractSeq[B[_ >: D with C <: B[_ >: D with C <: A]]] with Serializable]] TypeTag[List[scala.collection.Set[_ >: G with F <: B[_ >: G with F <: B[_ >: G with F <: A]]]]] @@ -6,6 +6,6 @@ TypeTag[List[scala.collection.Set[_ >: G with F <: B[_ >: G with F <: B[_ >: G w TypeTag[List[scala.collection.Set[_ >: G with F <: B[_ >: G with F <: B[_ >: G with F <: A]]]]] TypeTag[List[Seq[B[_ >: G with F <: B[_ >: G with F <: A]]]]] TypeTag[List[scala.collection.Map[_ >: F with C <: B[_ >: F with C <: B[_ >: F with C <: A]], B[_ >: G with D <: B[_ >: G with D <: A]]]]] -TypeTag[List[scala.collection.AbstractSeq[B[_ >: G with F <: B[_ >: G with F <: A]]] with scala.collection.LinearSeq[B[_ >: G with F <: B[_ >: G with F <: A]]] with java.io.Serializable]] +TypeTag[List[scala.collection.AbstractSeq[B[_ >: G with F <: B[_ >: G with F <: A]]] with scala.collection.LinearSeq[B[_ >: G with F <: B[_ >: G with F <: A]]] with Serializable]] TypeTag[List[Seq[B[_ >: G with F <: B[_ >: G with F <: A]]]]] TypeTag[List[Seq[B[_ >: G with F <: B[_ >: G with F <: A]]]]] From 8e531d3779d051eaf9f18abd4b5f9af977b11164 Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Mon, 8 Sep 2014 14:15:09 +1000 Subject: [PATCH 522/826] Fix broken URL for MathJAX Javascript dependency. Loaded using an DNS alias for the CDN, as per the [instructions](http://docs.mathjax.org/en/latest/configuration.html) I also switched from `latest` to `2.3-latest`, so that we don't automatically perform major upgrades. --- spec/_layouts/default.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/spec/_layouts/default.yml b/spec/_layouts/default.yml index 7f17ba30b020..d3296c6f5dba 100644 --- a/spec/_layouts/default.yml +++ b/spec/_layouts/default.yml @@ -11,7 +11,7 @@ } }); - + From 6317ae2dbb49f271ff9bba482f8ce38f2ffafe52 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Mon, 8 Sep 2014 08:51:39 +0200 Subject: [PATCH 523/826] SI-8764 remove Xexperimental special Product members for case classes `productElement` and `productIterator` return types under Xexperimental use the weak lub of the case class's parameters instead of just Any. This isn't really useful, nor tested and it is broken (SI-8764) anyway. The special casing of `productElement` and `productIterator` was introduced with `ProductN` support in case classes (e412524), but was not removed when `ProductN` support went away (70996f8, d7f498a, b7395e9, 317a105). --- .../nsc/typechecker/SyntheticMethods.scala | 24 +++---------------- 1 file changed, 3 insertions(+), 21 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala index 9516f9413590..14653a38e1b0 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala @@ -84,24 +84,6 @@ trait SyntheticMethods extends ast.TreeDSL { def accessors = clazz.caseFieldAccessors val arity = accessors.size - // If this is ProductN[T1, T2, ...], accessorLub is the lub of T1, T2, ..., . - // !!! Hidden behind -Xexperimental due to bummer type inference bugs. - // Refining from Iterator[Any] leads to types like - // - // Option[Int] { def productIterator: Iterator[String] } - // - // appearing legitimately, but this breaks invariant places - // like Tags and Arrays which are not robust and infer things - // which they shouldn't. - val accessorLub = ( - if (settings.Xexperimental) { - global.weakLub(accessors map (_.tpe.finalResultType)) match { - case RefinedType(parents, decls) if !decls.isEmpty => intersectionType(parents) - case tp => tp - } - } - else AnyTpe - ) def forwardToRuntime(method: Symbol): Tree = forwardMethod(method, getMember(ScalaRunTimeModule, (method.name prepend "_")))(mkThis :: _) @@ -122,8 +104,8 @@ trait SyntheticMethods extends ast.TreeDSL { } } def productIteratorMethod = { - createMethod(nme.productIterator, iteratorOfType(accessorLub))(_ => - gen.mkMethodCall(ScalaRunTimeModule, nme.typedProductIterator, List(accessorLub), List(mkThis)) + createMethod(nme.productIterator, iteratorOfType(AnyTpe))(_ => + gen.mkMethodCall(ScalaRunTimeModule, nme.typedProductIterator, List(AnyTpe), List(mkThis)) ) } @@ -243,7 +225,7 @@ trait SyntheticMethods extends ast.TreeDSL { List( Product_productPrefix -> (() => constantNullary(nme.productPrefix, clazz.name.decode)), Product_productArity -> (() => constantNullary(nme.productArity, arity)), - Product_productElement -> (() => perElementMethod(nme.productElement, accessorLub)(mkThisSelect)), + Product_productElement -> (() => perElementMethod(nme.productElement, AnyTpe)(mkThisSelect)), Product_iterator -> (() => productIteratorMethod), Product_canEqual -> (() => canEqualMethod) // This is disabled pending a reimplementation which doesn't add any From 861ad72b59c5ea7856b2853c092aaeb15453caea Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Wed, 3 Sep 2014 09:38:36 +0200 Subject: [PATCH 524/826] Address PR feedback, fix MultiChoiceSetting.contains --- .../tools/nsc/settings/MutableSettings.scala | 7 ++-- .../scala/tools/nsc/settings/Warnings.scala | 33 ++++++++----------- .../tools/nsc/settings/SettingsTest.scala | 2 ++ 3 files changed, 20 insertions(+), 22 deletions(-) diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala index 78d70610666c..1f75afd49a6a 100644 --- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala @@ -553,7 +553,7 @@ class MutableSettings(val errorFn: String => Unit) } /** - * Each [[MultiChoiceSetting]] takes a MultiChoiceEnumeration as domain. The enumartion may + * Each [[MultiChoiceSetting]] takes a MultiChoiceEnumeration as domain. The enumeration may * use the Choice class to define values, or simply use the default `Value` constructor: * * object SettingDomain extends MultiChoiceEnumeration { val arg1, arg2 = Value } @@ -572,7 +572,8 @@ class MutableSettings(val errorFn: String => Unit) case class Choice(name: String, help: String = "", expandsTo: List[Choice] = Nil) extends Val(name) } - /** A Setting that collects string-valued settings from an enumerated domain. + /** + * A Setting that collects string-valued settings from an enumerated domain. * - These choices can be turned on or off: "-option:on,-off" * - If an option is set both on and off, then the option is on * - The choice "_" enables all choices that have not been explicitly disabled @@ -744,7 +745,7 @@ class MutableSettings(val errorFn: String => Unit) sawHelp = false } def unparse: List[String] = value.toList map (s => s"$name:$s") - def contains(s: String) = value contains (domain withName s) + def contains(s: String) = domain.values.find(_.toString == s).exists(value.contains) } /** A setting that accumulates all strings supplied to it, diff --git a/src/compiler/scala/tools/nsc/settings/Warnings.scala b/src/compiler/scala/tools/nsc/settings/Warnings.scala index 574825874d51..c400e8c29ca2 100644 --- a/src/compiler/scala/tools/nsc/settings/Warnings.scala +++ b/src/compiler/scala/tools/nsc/settings/Warnings.scala @@ -58,7 +58,7 @@ trait Warnings { val PackageObjectClasses = LintWarning("package-object-classes", "Class or object defined in package object.") val UnsoundMatch = LintWarning("unsound-match", "Pattern match may not be typesafe.") - def allWarnings = values.toSeq.asInstanceOf[Seq[LintWarning]] + def allLintWarnings = values.toSeq.asInstanceOf[Seq[LintWarning]] } import LintWarnings._ @@ -91,24 +91,19 @@ trait Warnings { def YwarnInferAny = warnInferAny // The Xlint warning group. - val lint: MultiChoiceSetting[LintWarnings.type] = { - import LintWarnings._ - - allWarnings.sortBy(_.name) foreach { - case l: LintWarning if l.yAliased => - BooleanSetting(s"-Ywarn-${l.name}", {l.help}) withPostSetHook { s => - lint.add(if (s) l.name else s"-${l.name}") - } // withDeprecationMessage s"Enable -Xlint:${c._1}" - case _ => - } - - MultiChoiceSetting( - name = "-Xlint", - helpArg = "warning", - descr = "Enable or disable specific warnings", - domain = LintWarnings, - default = Some(List("_")) - ) + val lint = MultiChoiceSetting( + name = "-Xlint", + helpArg = "warning", + descr = "Enable or disable specific warnings", + domain = LintWarnings, + default = Some(List("_"))) + + allLintWarnings foreach { + case w if w.yAliased => + BooleanSetting(s"-Ywarn-${w.name}", {w.help}) withPostSetHook { s => + lint.add(if (s) w.name else s"-${w.name}") + } // withDeprecationMessage s"Enable -Xlint:${c._1}" + case _ => } private lazy val warnSelectNullable = BooleanSetting("-Xcheck-null", "This option is obsolete and does nothing.") diff --git a/test/junit/scala/tools/nsc/settings/SettingsTest.scala b/test/junit/scala/tools/nsc/settings/SettingsTest.scala index 0b8029326e69..eda0c278342f 100644 --- a/test/junit/scala/tools/nsc/settings/SettingsTest.scala +++ b/test/junit/scala/tools/nsc/settings/SettingsTest.scala @@ -158,6 +158,8 @@ class SettingsTest { assertTrue(check("-m:-d,ac")(_.value == Set(a,c))) assertTrue(check("-m:-b,ac,uber")(_.value == Set(a,c,d))) + assertFalse(check("-m:uber")(_.contains("i-m-not-an-option"))) + assertThrows[IllegalArgumentException](check("-m:-_")(_ => true), _ contains "'-_' is not a valid choice") assertThrows[IllegalArgumentException](check("-m:a,b,-ab")(_ => true), _ contains "'ab' cannot be negated") assertThrows[IllegalArgumentException](check("-m:a,ac,-uber,uber")(_ => true), _ contains "'uber' cannot be negated") From 1ea684341ba9eeff7c6bc6f943fb2d048a9ff5a3 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Mon, 8 Sep 2014 19:25:47 +0200 Subject: [PATCH 525/826] Make MultiChoiceSetting.compute easier to understand --- .../tools/nsc/settings/MutableSettings.scala | 29 +++++++------------ 1 file changed, 11 insertions(+), 18 deletions(-) diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala index 1f75afd49a6a..bbe21477cb9b 100644 --- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala @@ -604,10 +604,9 @@ class MutableSettings(val errorFn: String => Unit) withHelpSyntax(s"$name:<_,$helpArg,-$helpArg>") object ChoiceOrVal { - def unapply(a: Any): Option[(String, String, List[domain.Choice])] = a match { + def unapply(a: domain.Value): Option[(String, String, List[domain.Choice])] = a match { case c: domain.Choice => Some((c.name, c.help, c.expandsTo)) case v: domain.Value => Some((v.toString, "", Nil)) - case _ => None } } @@ -641,31 +640,25 @@ class MutableSettings(val errorFn: String => Unit) /** (Re)compute from current yeas, nays, wildcard status. */ def compute() = { - def nonExpanding(vs: domain.ValueSet) = vs filter { - case ChoiceOrVal(_, _, others) => others.isEmpty + def simple(v: domain.Value) = v match { + case ChoiceOrVal(_, _, Nil) => true + case _ => false } /** - * Expand an option, if necessary recursively. Expanding options are not included in the - * result (consistent with "_", which is not in the values either). Explicitly excluded - * options (in nays) are not added. + * Expand an expanding option, if necessary recursively. Expanding options are not included in + * the result (consistent with "_", which is not in `value` either). * * Note: by precondition, options in nays are not expanding, they can only be leaves. */ def expand(vs: domain.ValueSet): domain.ValueSet = vs flatMap { - // expand - case c @ ChoiceOrVal(_, _, others) if others.nonEmpty => expand(domain.ValueSet(others: _*)) - case c @ ChoiceOrVal(_, _, _) if !nays(c) => domain.ValueSet(c) - case _ => domain.ValueSet.empty + case c @ ChoiceOrVal(_, _, Nil) => domain.ValueSet(c) + case ChoiceOrVal(_, _, others) => expand(domain.ValueSet(others: _*)) } - val expandedYeas = expand(yeas) - - // we include everything, except those explicitly disabled. - val expandedAll = if (sawAll) nonExpanding(domain.values) &~ nays - else domain.ValueSet.empty - - value = nonExpanding(yeas) | expandedYeas | expandedAll + // yeas from _ or expansions are weak: an explicit nay will disable them + val weakYeas = if (sawAll) domain.values filter simple else expand(yeas filterNot simple) + value = (yeas filter simple) | (weakYeas &~ nays) } /** Add a named choice to the multichoice value. */ From e01b461ad98a7cd6183d222ef91c674306c62ffd Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Mon, 18 Aug 2014 10:18:46 +0200 Subject: [PATCH 526/826] [nomaster] SI-8764 fix return type of case class productElement under Xexperimental Under Xexperimental, productElement now returns the lub instead of the weak lub of case class parameter types (numeric widening shouldn't magically happen *inside* productElement). This was removed from 2.12.x in 6317ae2. --- .../tools/nsc/typechecker/SyntheticMethods.scala | 2 +- test/files/neg/t8764.check | 6 ++++++ test/files/neg/t8764.flags | 1 + test/files/neg/t8764.scala | 9 +++++++++ test/files/run/t8764.check | 5 +++++ test/files/run/t8764.flags | 1 + test/files/run/t8764.scala | 16 ++++++++++++++++ 7 files changed, 39 insertions(+), 1 deletion(-) create mode 100644 test/files/neg/t8764.check create mode 100644 test/files/neg/t8764.flags create mode 100644 test/files/neg/t8764.scala create mode 100644 test/files/run/t8764.check create mode 100644 test/files/run/t8764.flags create mode 100644 test/files/run/t8764.scala diff --git a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala index d0237fb46813..bedca8897417 100644 --- a/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala +++ b/src/compiler/scala/tools/nsc/typechecker/SyntheticMethods.scala @@ -95,7 +95,7 @@ trait SyntheticMethods extends ast.TreeDSL { // which they shouldn't. val accessorLub = ( if (settings.Xexperimental) { - global.weakLub(accessors map (_.tpe.finalResultType)) match { + global.lub(accessors map (_.tpe.finalResultType)) match { case RefinedType(parents, decls) if !decls.isEmpty => intersectionType(parents) case tp => tp } diff --git a/test/files/neg/t8764.check b/test/files/neg/t8764.check new file mode 100644 index 000000000000..6d89ebe106b8 --- /dev/null +++ b/test/files/neg/t8764.check @@ -0,0 +1,6 @@ +t8764.scala:8: error: type mismatch; + found : AnyVal + required: Double + val d: Double = a.productElement(0) + ^ +one error found diff --git a/test/files/neg/t8764.flags b/test/files/neg/t8764.flags new file mode 100644 index 000000000000..48fd867160ba --- /dev/null +++ b/test/files/neg/t8764.flags @@ -0,0 +1 @@ +-Xexperimental diff --git a/test/files/neg/t8764.scala b/test/files/neg/t8764.scala new file mode 100644 index 000000000000..dc5bfb016067 --- /dev/null +++ b/test/files/neg/t8764.scala @@ -0,0 +1,9 @@ +object Main { + + case class IntAndDouble(i: Int, d: Double) + + // a.productElement used to be Int => Double + // now: Int => AnyVal + val a = IntAndDouble(1, 5.0) + val d: Double = a.productElement(0) +} diff --git a/test/files/run/t8764.check b/test/files/run/t8764.check new file mode 100644 index 000000000000..6260069602ae --- /dev/null +++ b/test/files/run/t8764.check @@ -0,0 +1,5 @@ +IntOnly: should return an unboxed int +Int: int +IntAndDouble: should just box and return Anyval +Double: class java.lang.Double +Int: class java.lang.Integer diff --git a/test/files/run/t8764.flags b/test/files/run/t8764.flags new file mode 100644 index 000000000000..48fd867160ba --- /dev/null +++ b/test/files/run/t8764.flags @@ -0,0 +1 @@ +-Xexperimental diff --git a/test/files/run/t8764.scala b/test/files/run/t8764.scala new file mode 100644 index 000000000000..decc658f6e0c --- /dev/null +++ b/test/files/run/t8764.scala @@ -0,0 +1,16 @@ +object Test extends App { +case class IntOnly(i: Int, j: Int) + +println("IntOnly: should return an unboxed int") +val a = IntOnly(1, 2) +val i: Int = a.productElement(0) +println(s"Int: ${a.productElement(0).getClass}") + +case class IntAndDouble(i: Int, d: Double) + +println("IntAndDouble: should just box and return Anyval") +val b = IntAndDouble(1, 2.0) +val j: AnyVal = b.productElement(0) +println(s"Double: ${b.productElement(1).getClass}") +println(s"Int: ${b.productElement(0).getClass}") +} From 52bf75a759fe4d29dc218bb6417bff9d8f455be6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Garillot?= Date: Mon, 28 Jul 2014 15:51:35 +0200 Subject: [PATCH 527/826] Bump versions for Eclipse .classpath. Remove cruft in repl. --- src/eclipse/partest/.classpath | 2 +- src/eclipse/repl/.classpath | 1 - src/eclipse/scaladoc/.classpath | 6 +++--- 3 files changed, 4 insertions(+), 5 deletions(-) diff --git a/src/eclipse/partest/.classpath b/src/eclipse/partest/.classpath index 7f28868d95ee..7e2f119193fc 100644 --- a/src/eclipse/partest/.classpath +++ b/src/eclipse/partest/.classpath @@ -5,7 +5,7 @@ - + diff --git a/src/eclipse/repl/.classpath b/src/eclipse/repl/.classpath index 8ff9aabfbf0b..cbaabb9af1af 100644 --- a/src/eclipse/repl/.classpath +++ b/src/eclipse/repl/.classpath @@ -3,7 +3,6 @@ - diff --git a/src/eclipse/scaladoc/.classpath b/src/eclipse/scaladoc/.classpath index c8f0e89b8a8c..ee6427176a79 100644 --- a/src/eclipse/scaladoc/.classpath +++ b/src/eclipse/scaladoc/.classpath @@ -6,8 +6,8 @@ - - - + + +         From f43e758a2d4584709ac587933882113b05cea825 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Garillot?= Date: Tue, 29 Jul 2014 11:09:18 +0200 Subject: [PATCH 528/826] Removing deprecations drive-by cleanups. --- .../scala/tools/nsc/interactive/Global.scala | 2 +- .../scala/tools/nsc/doc/base/MemberLookupBase.scala | 8 ++++---- .../doc/html/page/diagram/DotDiagramGenerator.scala | 10 +++++----- .../scala/tools/nsc/doc/model/MemberLookup.scala | 2 +- .../scala/tools/nsc/doc/model/ModelFactory.scala | 10 +++++----- .../tools/nsc/doc/model/ModelFactoryTypeSupport.scala | 2 +- .../scala/tools/nsc/doc/model/TreeFactory.scala | 2 +- .../nsc/doc/model/diagram/DiagramDirectiveParser.scala | 2 +- 8 files changed, 19 insertions(+), 19 deletions(-) diff --git a/src/interactive/scala/tools/nsc/interactive/Global.scala b/src/interactive/scala/tools/nsc/interactive/Global.scala index 174254d52369..f50153e1e2d0 100644 --- a/src/interactive/scala/tools/nsc/interactive/Global.scala +++ b/src/interactive/scala/tools/nsc/interactive/Global.scala @@ -1091,7 +1091,7 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "") val implicitlyAdded = viaView != NoSymbol members.add(sym, pre, implicitlyAdded) { (s, st) => new TypeMember(s, st, - context.isAccessible(if (s.hasGetter) s.getter(s.owner) else s, pre, superAccess && !implicitlyAdded), + context.isAccessible(if (s.hasGetter) s.getterIn(s.owner) else s, pre, superAccess && !implicitlyAdded), inherited, viaView) } diff --git a/src/scaladoc/scala/tools/nsc/doc/base/MemberLookupBase.scala b/src/scaladoc/scala/tools/nsc/doc/base/MemberLookupBase.scala index cc217d2f800b..f853df048489 100755 --- a/src/scaladoc/scala/tools/nsc/doc/base/MemberLookupBase.scala +++ b/src/scaladoc/scala/tools/nsc/doc/base/MemberLookupBase.scala @@ -62,15 +62,15 @@ trait MemberLookupBase { syms.flatMap { case (sym, owner) => // reconstruct the original link def linkName(sym: Symbol) = { - def nameString(s: Symbol) = s.nameString + (if ((s.isModule || s.isModuleClass) && !s.isPackage) "$" else "") - val packageSuffix = if (sym.isPackage) ".package" else "" + def nameString(s: Symbol) = s.nameString + (if ((s.isModule || s.isModuleClass) && !s.hasPackageFlag) "$" else "") + val packageSuffix = if (sym.hasPackageFlag) ".package" else "" sym.ownerChain.reverse.filterNot(isRoot(_)).map(nameString(_)).mkString(".") + packageSuffix } - if (sym.isClass || sym.isModule || sym.isTrait || sym.isPackage) + if (sym.isClass || sym.isModule || sym.isTrait || sym.hasPackageFlag) findExternalLink(sym, linkName(sym)) - else if (owner.isClass || owner.isModule || owner.isTrait || owner.isPackage) + else if (owner.isClass || owner.isModule || owner.isTrait || owner.hasPackageFlag) findExternalLink(sym, linkName(owner) + "@" + externalSignature(sym)) else None diff --git a/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala b/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala index 4ff436bdc677..dc823ab1e593 100644 --- a/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala +++ b/src/scaladoc/scala/tools/nsc/doc/html/page/diagram/DotDiagramGenerator.scala @@ -364,7 +364,7 @@ class DotDiagramGenerator(settings: doc.Settings) extends DiagramGenerator { // add an id and class attribute to the SVG element case Elem(prefix, "svg", attribs, scope, child @ _*) => { val klass = if (isInheritanceDiagram) "class-diagram" else "package-diagram" - Elem(prefix, "svg", attribs, scope, child map(x => transform(x)) : _*) % + Elem(prefix, "svg", attribs, scope, true, child map(x => transform(x)) : _*) % new UnprefixedAttribute("id", "graph" + counter, Null) % new UnprefixedAttribute("class", klass, Null) } @@ -378,7 +378,7 @@ class DotDiagramGenerator(settings: doc.Settings) extends DiagramGenerator { // assign id and class attributes to edges and nodes: // the id attribute generated by dot has the format: "{class}|{id}" case g @ Elem(prefix, "g", attribs, scope, children @ _*) if (List("edge", "node").contains((g \ "@class").toString)) => { - var res = new Elem(prefix, "g", attribs, scope, (children map(x => transform(x))): _*) + var res = new Elem(prefix, "g", attribs, scope, true, (children map(x => transform(x))): _*) val dotId = (g \ "@id").toString if (dotId.count(_ == '|') == 1) { val Array(klass, id) = dotId.toString.split("\\|") @@ -395,11 +395,11 @@ class DotDiagramGenerator(settings: doc.Settings) extends DiagramGenerator { val imageNode = val anchorNode = (g \ "a") match { case Seq(Elem(prefix, "a", attribs, scope, children @ _*)) => - transform(new Elem(prefix, "a", attribs, scope, (children ++ imageNode): _*)) + transform(new Elem(prefix, "a", attribs, scope, true, (children ++ imageNode): _*)) case _ => g \ "a" } - res = new Elem(prefix, "g", attribs, scope, anchorNode: _*) + res = new Elem(prefix, "g", attribs, scope, true, anchorNode: _*) DiagramStats.addFixedImage() } } @@ -413,7 +413,7 @@ class DotDiagramGenerator(settings: doc.Settings) extends DiagramGenerator { scala.xml.Text("") // apply recursively case Elem(prefix, label, attribs, scope, child @ _*) => - Elem(prefix, label, attribs, scope, child map(x => transform(x)) : _*) + Elem(prefix, label, attribs, scope, true, child map(x => transform(x)) : _*) case x => x } diff --git a/src/scaladoc/scala/tools/nsc/doc/model/MemberLookup.scala b/src/scaladoc/scala/tools/nsc/doc/model/MemberLookup.scala index 64eb1adbea24..20aaab29fca0 100644 --- a/src/scaladoc/scala/tools/nsc/doc/model/MemberLookup.scala +++ b/src/scaladoc/scala/tools/nsc/doc/model/MemberLookup.scala @@ -40,7 +40,7 @@ trait MemberLookup extends base.MemberLookupBase { override def findExternalLink(sym: Symbol, name: String): Option[LinkToExternal] = { val sym1 = if (sym == AnyClass || sym == AnyRefClass || sym == AnyValClass || sym == NothingClass) ListClass - else if (sym.isPackage) + else if (sym.hasPackageFlag) /* Get package object which has associatedFile ne null */ sym.info.member(newTermName("package")) else sym diff --git a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala index ef84ac42bafd..2993c4c4b965 100644 --- a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala +++ b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactory.scala @@ -89,10 +89,10 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { trait TemplateImpl extends EntityImpl with TemplateEntity { override def qualifiedName: String = if (inTemplate == null || inTemplate.isRootPackage) name else optimize(inTemplate.qualifiedName + "." + name) - def isPackage = sym.isPackage + def isPackage = sym.hasPackageFlag def isTrait = sym.isTrait def isClass = sym.isClass && !sym.isTrait - def isObject = sym.isModule && !sym.isPackage + def isObject = sym.isModule && !sym.hasPackageFlag def isCaseClass = sym.isCaseClass def isRootPackage = false def selfType = if (sym.thisSym eq sym) None else Some(makeType(sym.thisSym.typeOfThis, this)) @@ -250,7 +250,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { def valueParams: List[List[ValueParam]] = Nil /** TODO, these are now only computed for DocTemplates */ def parentTypes = - if (sym.isPackage || sym == AnyClass) List() else { + if (sym.hasPackageFlag || sym == AnyClass) List() else { val tps = (this match { case a: AliasType => sym.tpe.dealias.parents case a: AbstractType => sym.info.bounds match { @@ -661,7 +661,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { s != EmptyPackage && s != RootPackage } }) - else if (bSym.isPackage) // (2) + else if (bSym.hasPackageFlag) // (2) if (settings.skipPackage(makeQualifiedName(bSym))) None else @@ -772,7 +772,7 @@ class ModelFactory(val global: Global, val settings: doc.Settings) { Some(new MemberTemplateImpl(bSym, inTpl) with AliasImpl with AliasType { override def isAliasType = true }) - else if (!modelFinished && (bSym.isPackage || templateShouldDocument(bSym, inTpl))) + else if (!modelFinished && (bSym.hasPackageFlag || templateShouldDocument(bSym, inTpl))) modelCreation.createTemplate(bSym, inTpl) else None diff --git a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryTypeSupport.scala b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryTypeSupport.scala index 2b7e2506d43b..ea72fa609598 100644 --- a/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryTypeSupport.scala +++ b/src/scaladoc/scala/tools/nsc/doc/model/ModelFactoryTypeSupport.scala @@ -94,7 +94,7 @@ trait ModelFactoryTypeSupport { LinkToMember(bMbr, oTpl) case _ => val name = makeQualifiedName(bSym) - if (!bSym.owner.isPackage) + if (!bSym.owner.hasPackageFlag) Tooltip(name) else findExternalLink(bSym, name).getOrElse ( diff --git a/src/scaladoc/scala/tools/nsc/doc/model/TreeFactory.scala b/src/scaladoc/scala/tools/nsc/doc/model/TreeFactory.scala index 86a7a67160be..c1228e8735ce 100755 --- a/src/scaladoc/scala/tools/nsc/doc/model/TreeFactory.scala +++ b/src/scaladoc/scala/tools/nsc/doc/model/TreeFactory.scala @@ -49,7 +49,7 @@ trait TreeFactory { thisTreeFactory: ModelFactory with TreeFactory => case _ => } else if (asym.isTerm && asym.owner.isClass){ - if (asym.isSetter) asym = asym.getter(asym.owner) + if (asym.isSetter) asym = asym.getterIn(asym.owner) makeTemplate(asym.owner) match { case docTmpl: DocTemplateImpl => val mbrs: Option[MemberImpl] = findMember(asym, docTmpl) diff --git a/src/scaladoc/scala/tools/nsc/doc/model/diagram/DiagramDirectiveParser.scala b/src/scaladoc/scala/tools/nsc/doc/model/diagram/DiagramDirectiveParser.scala index 44d8886e4ed7..bcb97639c63a 100644 --- a/src/scaladoc/scala/tools/nsc/doc/model/diagram/DiagramDirectiveParser.scala +++ b/src/scaladoc/scala/tools/nsc/doc/model/diagram/DiagramDirectiveParser.scala @@ -177,7 +177,7 @@ trait DiagramDirectiveParser { def warning(message: String) = { // we need the position from the package object (well, ideally its comment, but yeah ...) - val sym = if (template.sym.isPackage) template.sym.info.member(global.nme.PACKAGE) else template.sym + val sym = if (template.sym.hasPackageFlag) template.sym.info.member(global.nme.PACKAGE) else template.sym assert((sym != global.NoSymbol) || (sym == global.rootMirror.RootPackage)) global.reporter.warning(sym.pos, message) } From a6946eebe6237310724d9338e141adc41bca9b4e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fran=C3=A7ois=20Garillot?= Date: Tue, 29 Jul 2014 11:51:26 +0200 Subject: [PATCH 529/826] Change Synchronized(Set|Map) to Java concurrency --- .../scala/tools/nsc/interactive/Global.scala | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/src/interactive/scala/tools/nsc/interactive/Global.scala b/src/interactive/scala/tools/nsc/interactive/Global.scala index f50153e1e2d0..fdedaa600cbf 100644 --- a/src/interactive/scala/tools/nsc/interactive/Global.scala +++ b/src/interactive/scala/tools/nsc/interactive/Global.scala @@ -19,6 +19,8 @@ import scala.annotation.{ elidable, tailrec } import scala.language.implicitConversions import scala.tools.nsc.typechecker.Typers import scala.util.control.Breaks._ +import java.util.concurrent.ConcurrentHashMap +import scala.collection.JavaConverters.mapAsScalaMapConverter /** * This trait allows the IDE to have an instance of the PC that @@ -160,19 +162,18 @@ class Global(settings: Settings, _reporter: Reporter, projectName: String = "") /** A map of all loaded files to the rich compilation units that correspond to them. */ - val unitOfFile = new LinkedHashMap[AbstractFile, RichCompilationUnit] with - SynchronizedMap[AbstractFile, RichCompilationUnit] { + val unitOfFile = mapAsScalaMapConverter(new ConcurrentHashMap[AbstractFile, RichCompilationUnit] { override def put(key: AbstractFile, value: RichCompilationUnit) = { val r = super.put(key, value) - if (r.isEmpty) debugLog("added unit for "+key) + if (r == null) debugLog("added unit for "+key) r } - override def remove(key: AbstractFile) = { + override def remove(key: Any) = { val r = super.remove(key) - if (r.nonEmpty) debugLog("removed unit for "+key) + if (r != null) debugLog("removed unit for "+key) r } - } + }).asScala /** A set containing all those files that need to be removed * Units are removed by getUnit, typically once a unit is finished compiled. From 5966a11ae1f494f1c7271a6a574b3ff4365f5847 Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Tue, 9 Sep 2014 16:18:24 +0200 Subject: [PATCH 530/826] -Xfundep-materialization => -Yfundep-materialization To quote gkossakowski: Thinking about it more, could we hide this behind 'Y' flag instead? We have lesser obligation to keep around Y flags and this is something we should remove from 2.11/2.12. --- src/compiler/scala/tools/nsc/settings/ScalaSettings.scala | 2 +- src/compiler/scala/tools/nsc/typechecker/Macros.scala | 6 +++--- test/files/run/t5923a-fundep.flags | 2 +- test/files/run/t5923c.flags | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala index 3a6d183c324e..56fc4d7594c6 100644 --- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala @@ -111,7 +111,6 @@ trait ScalaSettings extends AbsScalaSettings val XnoPatmatAnalysis = BooleanSetting ("-Xno-patmat-analysis", "Don't perform exhaustivity/unreachability analysis. Also, ignore @switch annotation.") val XfullLubs = BooleanSetting ("-Xfull-lubs", "Retains pre 2.10 behavior of less aggressive truncation of least upper bounds.") val Xdivergence211 = BooleanSetting ("-Xdivergence211", "Turn on the 2.11 behavior of implicit divergence not terminating recursive implicit searches (SI-7291).") - val XfundepMaterialization = BooleanSetting("-Xfundep-materialization", "Turn on the 2.11 behavior of macro expansion being able to influence type inference in implicit searches") /** Compatibility stubs for options whose value name did * not previously match the option name. @@ -180,6 +179,7 @@ trait ScalaSettings extends AbsScalaSettings val YvirtClasses = false // too embryonic to even expose as a -Y //BooleanSetting ("-Yvirtual-classes", "Support virtual classes") val exposeEmptyPackage = BooleanSetting("-Yexpose-empty-package", "Internal only: expose the empty package.").internalOnly() + val YfundepMaterialization = BooleanSetting("-Yfundep-materialization", "Turn on the 2.11 behavior of macro expansion being able to influence type inference in implicit searches") def stop = stopAfter diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala index f0770e84c4a4..c0844ec8fc64 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala @@ -713,7 +713,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces { var expectedTpe = expandee.tpe if (isNullaryInvocation(expandee)) expectedTpe = expectedTpe.finalResultType - if (settings.XfundepMaterialization.value) { + if (settings.YfundepMaterialization.value) { // approximation is necessary for whitebox macros to guide type inference // read more in the comments for onDelayed below val undetparams = expectedTpe collect { case tp if tp.typeSymbol.isTypeParameter => tp.typeSymbol } @@ -785,7 +785,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces { // but is enabled by default in Scala 2.11. val shouldInstantiate = typer.context.undetparams.nonEmpty && !inPolyMode(mode) if (shouldInstantiate) { - if (settings.XfundepMaterialization.value) { + if (settings.YfundepMaterialization.value) { forced += delayed typer.infer.inferExprInstance(delayed, typer.context.extractUndetparams(), pt, keepNothings = false) macroExpand(typer, delayed, mode, pt) @@ -912,7 +912,7 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces { private val delayed = perRunCaches.newWeakMap[Tree, scala.collection.mutable.Set[Int]] private def isDelayed(expandee: Tree) = delayed contains expandee private def calculateUndetparams(expandee: Tree): scala.collection.mutable.Set[Int] = - // !settings.XfundepMaterialization.value implies forced.isEmpty + // !settings.YfundepMaterialization.value implies forced.isEmpty if (forced(expandee)) scala.collection.mutable.Set[Int]() else delayed.getOrElse(expandee, { val calculated = scala.collection.mutable.Set[Symbol]() diff --git a/test/files/run/t5923a-fundep.flags b/test/files/run/t5923a-fundep.flags index c8b4511960d0..384b48d1b004 100644 --- a/test/files/run/t5923a-fundep.flags +++ b/test/files/run/t5923a-fundep.flags @@ -1 +1 @@ --Xfundep-materialization \ No newline at end of file +-Yfundep-materialization \ No newline at end of file diff --git a/test/files/run/t5923c.flags b/test/files/run/t5923c.flags index c8b4511960d0..384b48d1b004 100644 --- a/test/files/run/t5923c.flags +++ b/test/files/run/t5923c.flags @@ -1 +1 @@ --Xfundep-materialization \ No newline at end of file +-Yfundep-materialization \ No newline at end of file From a3dfb43263a9d29d47f34ad8d183f7a01f3a1ea7 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Wed, 20 Aug 2014 17:23:56 +0200 Subject: [PATCH 531/826] Removed empty class, unused imports --- .../scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala | 1 - .../scala/tools/nsc/backend/jvm/BCodeHelpers.scala | 9 ++------- 2 files changed, 2 insertions(+), 8 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index 397171049fa0..d71d71362eb8 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -9,7 +9,6 @@ package tools.nsc package backend package jvm -import scala.collection.{ mutable, immutable } import scala.annotation.switch import scala.tools.asm diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala index 5670715cd3ba..14bffd67ab19 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala @@ -782,14 +782,9 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters { } } // end of trait BCClassGen - /* basic functionality for class file building of plain, mirror, and beaninfo classes. */ - abstract class JBuilder extends BCInnerClassGen { - - } // end of class JBuilder - /* functionality for building plain and mirror classes */ abstract class JCommonBuilder - extends JBuilder + extends BCInnerClassGen with BCAnnotGen with BCForwardersGen with BCPickles { } @@ -851,7 +846,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters { } // end of class JMirrorBuilder /* builder of bean info classes */ - class JBeanInfoBuilder extends JBuilder { + class JBeanInfoBuilder extends BCInnerClassGen { /* * Generate a bean info class that describes the given class. From 90781e874adb1af44a43d3e64d403230970b423d Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Fri, 22 Aug 2014 09:50:44 +0200 Subject: [PATCH 532/826] Eliminate unreachable code in GenBCode We rely on dead code elimination provided by the ASM framework, as described in the ASM User Guide (http://asm.ow2.org/index.html), Section 8.2.1. It runs a data flow analysis, which only computes information for reachable instructions. Instructions for which no data is available after the analyis are unreachable. There's one issue with the ASM framework (or the way we use it): Data flow analysis requires the maxlocals and maxstack of each method to be computed. The ASM framework calculates these maxes only when writing the classfiles, not during code generation. In order to run DCE, we therefore run a MethodWriter beforehand on every method. This assings the MethodNode's maxStack/maxLocals, but it does more work (writes the instructions to a byte array). This is also what Miguel uses on his branch. The change is basically the same as https://github.com/lrytz/scala/commit/bfadf92c20. We could probably make this faster (and allocate less memory) by hacking the ASM framework: create a subclass of MethodWriter with a /dev/null byteVector. Another option would be to create a separate visitor for computing those values, duplicating the functionality from the MethodWriter. For now, I added some timers to be able to measure the time DCE takes. Here's compiling the library with -Ystatistics:jvm time in backend : 1 spans, 6597ms bcode initialization : 1 spans, 8ms (0.1%) code generation : 1 spans, 4580ms (69.4%) dead code elimination : 3771 spans, 742ms (11.2%) classfile writing : 1 spans, 879ms (13.3%) --- src/asm/scala/tools/asm/MethodWriter.java | 10 ++- .../scala/tools/nsc/backend/jvm/BTypes.scala | 2 + .../tools/nsc/backend/jvm/BackendStats.scala | 19 ++++ .../tools/nsc/backend/jvm/GenBCode.scala | 19 +++- .../tools/nsc/backend/jvm/opt/LocalOpt.scala | 86 +++++++++++++++++++ .../tools/nsc/settings/ScalaSettings.scala | 2 +- 6 files changed, 134 insertions(+), 4 deletions(-) create mode 100644 src/compiler/scala/tools/nsc/backend/jvm/BackendStats.scala create mode 100644 src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala diff --git a/src/asm/scala/tools/asm/MethodWriter.java b/src/asm/scala/tools/asm/MethodWriter.java index 0c4130e4997d..d30e04c62554 100644 --- a/src/asm/scala/tools/asm/MethodWriter.java +++ b/src/asm/scala/tools/asm/MethodWriter.java @@ -37,7 +37,7 @@ * @author Eric Bruneton * @author Eugene Kuleshov */ -class MethodWriter extends MethodVisitor { +public class MethodWriter extends MethodVisitor { /** * Pseudo access flag used to denote constructors. @@ -235,11 +235,19 @@ class MethodWriter extends MethodVisitor { */ private int maxStack; + public int getMaxStack() { + return maxStack; + } + /** * Maximum number of local variables for this method. */ private int maxLocals; + public int getMaxLocals() { + return maxLocals; + } + /** * Number of local variables in the current stack map frame. */ diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala index 7bf61b4f513a..53ac5bfdc7ca 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala @@ -713,6 +713,8 @@ abstract class BTypes { // TODO @lry I don't really understand the reasoning here. // Both this and other are classes. The code takes (transitively) all superclasses and // finds the first common one. + // MOST LIKELY the answer can be found here, see the comments and links by Miguel: + // - https://issues.scala-lang.org/browse/SI-3872 firstCommonSuffix(this :: this.superClassesTransitive, other :: other.superClassesTransitive) } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BackendStats.scala b/src/compiler/scala/tools/nsc/backend/jvm/BackendStats.scala new file mode 100644 index 000000000000..921aef7aca11 --- /dev/null +++ b/src/compiler/scala/tools/nsc/backend/jvm/BackendStats.scala @@ -0,0 +1,19 @@ +/* NSC -- new Scala compiler + * Copyright 2005-2014 LAMP/EPFL + * @author Martin Odersky + */ + +package scala.tools.nsc +package backend.jvm + +import scala.reflect.internal.util.Statistics + +object BackendStats { + import Statistics.{newTimer, newSubTimer} + val bcodeTimer = newTimer("time in backend", "jvm") + + val bcodeInitTimer = newSubTimer("bcode initialization", bcodeTimer) + val bcodeGenStat = newSubTimer("code generation", bcodeTimer) + val bcodeDceTimer = newSubTimer("dead code elimination", bcodeTimer) + val bcodeWriteTimer = newSubTimer("classfile writing", bcodeTimer) +} diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala index 0a7c894a6911..a7cc1f69cfc6 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala @@ -11,6 +11,7 @@ package jvm import scala.collection.{ mutable, immutable } import scala.annotation.switch +import scala.reflect.internal.util.Statistics import scala.tools.asm @@ -222,8 +223,12 @@ abstract class GenBCode extends BCodeSyncAndTry { return } else { - try { addToQ3(item) } - catch { + try { + val dceStart = Statistics.startTimer(BackendStats.bcodeDceTimer) + opt.LocalOpt.removeUnreachableCode(item.plain) + Statistics.stopTimer(BackendStats.bcodeDceTimer, dceStart) + addToQ3(item) + } catch { case ex: Throwable => ex.printStackTrace() error(s"Error while emitting ${item.plain.name}\n${ex.getMessage}") @@ -272,10 +277,13 @@ abstract class GenBCode extends BCodeSyncAndTry { * */ override def run() { + val bcodeStart = Statistics.startTimer(BackendStats.bcodeTimer) + val initStart = Statistics.startTimer(BackendStats.bcodeInitTimer) arrivalPos = 0 // just in case scalaPrimitives.init() bTypes.intializeCoreBTypes() + Statistics.stopTimer(BackendStats.bcodeInitTimer, initStart) // initBytecodeWriter invokes fullName, thus we have to run it before the typer-dependent thread is activated. bytecodeWriter = initBytecodeWriter(cleanup.getEntryPoints) @@ -287,6 +295,7 @@ abstract class GenBCode extends BCodeSyncAndTry { // closing output files. bytecodeWriter.close() + Statistics.stopTimer(BackendStats.bcodeTimer, bcodeStart) /* TODO Bytecode can be verified (now that all classfiles have been written to disk) * @@ -312,9 +321,15 @@ abstract class GenBCode extends BCodeSyncAndTry { private def buildAndSendToDisk(needsOutFolder: Boolean) { feedPipeline1() + val genStart = Statistics.startTimer(BackendStats.bcodeGenStat) (new Worker1(needsOutFolder)).run() + Statistics.stopTimer(BackendStats.bcodeGenStat, genStart) + (new Worker2).run() + + val writeStart = Statistics.startTimer(BackendStats.bcodeWriteTimer) drainQ3() + Statistics.stopTimer(BackendStats.bcodeWriteTimer, writeStart) } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala new file mode 100644 index 000000000000..b3a515c2ae5f --- /dev/null +++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala @@ -0,0 +1,86 @@ +/* NSC -- new Scala compiler + * Copyright 2005-2014 LAMP/EPFL + * @author Martin Odersky + */ + +package scala.tools.nsc +package backend.jvm +package opt + +import scala.tools.asm.{MethodWriter, ClassWriter} +import scala.tools.asm.tree.analysis.{Analyzer, BasicValue, BasicInterpreter} +import scala.tools.asm.tree.{LabelNode, ClassNode, MethodNode} +import scala.collection.convert.decorateAsScala._ + +/** + * Intra-Method optimizations. + */ +object LocalOpt { + /** + * Remove unreachable instructions from all (non-abstract) methods. + * + * @param clazz The class whose methods are optimized + * @return `true` if unreachable code was elminated in some method, `false` otherwise. + */ + def removeUnreachableCode(clazz: ClassNode): Boolean = { + clazz.methods.asScala.foldLeft(false) { + case (changed, method) => removeUnreachableCode(method, clazz) || changed + } + } + + /** + * Remove unreachable code from a method. + * We rely on dead code elimination provided by the ASM framework, as described in the ASM User + * Guide (http://asm.ow2.org/index.html), Section 8.2.1. It runs a data flow analysis, which only + * computes Frame information for reachable instructions. Instructions for which no Frame data is + * available after the analyis are unreachable. + */ + private def removeUnreachableCode(method: MethodNode, ownerClass: ClassNode): Boolean = { + val initialSize = method.instructions.size + if (initialSize == 0) return false + + // The data flow analysis requires the maxLocals / maxStack fields of the method to be computed. + computeMaxLocalsMaxStack(method) + val a = new Analyzer[BasicValue](new BasicInterpreter) + a.analyze(ownerClass.name, method) + val frames = a.getFrames + + var i = 0 + val itr = method.instructions.iterator() + while (itr.hasNext) { + val ins = itr.next() + // Don't remove label nodes: they might be referenced for example in a LocalVariableNode + if (frames(i) == null && !ins.isInstanceOf[LabelNode]) { + // Instruction iterators allow removing during iteration. + // Removing is O(1): instructions are doubly linked list elements. + itr.remove() + } + i += 1 + } + + method.instructions.size == initialSize + } + + /** + * In order to run an Analyzer, the maxLocals / maxStack fields need to be available. The ASM + * framework only computes these values during bytecode generation. + * + * Sicne there's currently no better way, we run a bytecode generator on the method and extract + * the computed values. This required changes to the ASM codebase: + * - the [[MethodWriter]] class was made public + * - accessors for maxLocals / maxStack were added to the MethodWriter class + * + * We could probably make this faster (and allocate less memory) by hacking the ASM framework + * more: create a subclass of MethodWriter with a /dev/null byteVector. Another option would be + * to create a separate visitor for computing those values, duplicating the functionality from the + * MethodWriter. + */ + private def computeMaxLocalsMaxStack(method: MethodNode) { + val cw = new ClassWriter(ClassWriter.COMPUTE_MAXS) + val excs = method.exceptions.asScala.toArray + val mw = cw.visitMethod(method.access, method.name, method.desc, method.signature, excs).asInstanceOf[MethodWriter] + method.accept(mw) + method.maxLocals = mw.getMaxLocals + method.maxStack = mw.getMaxStack + } +} diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala index 91b03869e5a6..98eb831a9df2 100644 --- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala @@ -211,7 +211,7 @@ trait ScalaSettings extends AbsScalaSettings private def removalIn212 = "This flag is scheduled for removal in 2.12. If you have a case where you need this flag then please report a bug." - object YstatisticsPhases extends MultiChoiceEnumeration { val parser, typer, patmat, erasure, cleanup = Value } + object YstatisticsPhases extends MultiChoiceEnumeration { val parser, typer, patmat, erasure, cleanup, jvm = Value } val Ystatistics = { val description = "Print compiler statistics for specific phases" MultiChoiceSetting( From d3cfbb1db68dab3308edfa66bbdb497c5d3f0cb2 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Fri, 22 Aug 2014 23:10:48 +0200 Subject: [PATCH 533/826] -Yopt mulit-choice flag --- .../tools/nsc/backend/jvm/GenBCode.scala | 2 +- .../tools/nsc/settings/ScalaSettings.scala | 26 +++++++++++++++++++ 2 files changed, 27 insertions(+), 1 deletion(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala index a7cc1f69cfc6..a788cea532d9 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala @@ -225,7 +225,7 @@ abstract class GenBCode extends BCodeSyncAndTry { else { try { val dceStart = Statistics.startTimer(BackendStats.bcodeDceTimer) - opt.LocalOpt.removeUnreachableCode(item.plain) + if (settings.YoptUnreachableCode) opt.LocalOpt.removeUnreachableCode(item.plain) Statistics.stopTimer(BackendStats.bcodeDceTimer, dceStart) addToQ3(item) } catch { diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala index 98eb831a9df2..466e397dd7c8 100644 --- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala @@ -209,6 +209,32 @@ trait ScalaSettings extends AbsScalaSettings // the current standard is "inline" but we are moving towards "method" val Ydelambdafy = ChoiceSetting ("-Ydelambdafy", "strategy", "Strategy used for translating lambdas into JVM code.", List("inline", "method"), "inline") + object YoptChoices extends MultiChoiceEnumeration { + val unreachableCode = Choice("unreachable-code", "Eliminate unreachable code") + + val lNone = Choice("l:none", "Don't enable any optimizations") + + private val defaultChoices = List(unreachableCode) + val lDefault = Choice("l:default", "Enable default optimizations: "+ defaultChoices.mkString(","), expandsTo = defaultChoices) + + private val methodChoices = List(lDefault) + val lMethod = Choice("l:method", "Intra-method optimizations: "+ methodChoices.mkString(","), expandsTo = methodChoices) + + private val projectChoices = List(lMethod) + val lProject = Choice("l:project", "Cross-method optimizations within the current project: "+ projectChoices.mkString(","), expandsTo = projectChoices) + + private val classpathChoices = List(lProject) + val lClasspath = Choice("l:classpath", "Cross-method optmizations across the entire classpath: "+ classpathChoices.mkString(","), expandsTo = classpathChoices) + } + + val Yopt = MultiChoiceSetting( + name = "-Yopt", + helpArg = "optimization", + descr = "Enable optimizations", + domain = YoptChoices) + + def YoptUnreachableCode: Boolean = !Yopt.isSetByUser || Yopt.contains(YoptChoices.unreachableCode) + private def removalIn212 = "This flag is scheduled for removal in 2.12. If you have a case where you need this flag then please report a bug." object YstatisticsPhases extends MultiChoiceEnumeration { val parser, typer, patmat, erasure, cleanup, jvm = Value } From 44b5c261a8e585c5747380895aa06c84f9d63f6c Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Mon, 25 Aug 2014 23:13:05 +0200 Subject: [PATCH 534/826] JUnit tests for dead code elimination. JUnit tests may use tools from partest-extras (ASMConverters) --- build.xml | 1 + .../scala/tools/partest/ASMConverters.scala | 209 ++++++++++++++---- .../scala/tools/partest/BytecodeTest.scala | 30 ++- test/files/jvm/t6941/test.scala | 4 +- test/files/jvm/t7253/test.scala | 6 +- .../tools/nsc/backend/jvm/BTypesTest.scala | 1 - .../tools/nsc/backend/jvm/CodeGenTools.scala | 27 +++ .../backend/jvm/opt/UnreachableCodeTest.scala | 162 ++++++++++++++ .../tools/testing/AssertThrowsTest.scala | 11 +- 9 files changed, 379 insertions(+), 72 deletions(-) create mode 100644 test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala create mode 100644 test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala diff --git a/build.xml b/build.xml index 6c750e530df5..b43d8a826b96 100755 --- a/build.xml +++ b/build.xml @@ -970,6 +970,7 @@ TODO: + diff --git a/src/partest-extras/scala/tools/partest/ASMConverters.scala b/src/partest-extras/scala/tools/partest/ASMConverters.scala index d618e086f428..50057d058c45 100644 --- a/src/partest-extras/scala/tools/partest/ASMConverters.scala +++ b/src/partest-extras/scala/tools/partest/ASMConverters.scala @@ -2,70 +2,181 @@ package scala.tools.partest import scala.collection.JavaConverters._ import scala.tools.asm -import asm.tree.{ClassNode, MethodNode, InsnList} +import asm.{tree => t} /** Makes using ASM from ByteCodeTests more convenient. * * Wraps ASM instructions in case classes so that equals and toString work * for the purpose of bytecode diffing and pretty printing. */ -trait ASMConverters { - // wrap ASM's instructions so we get case class-style `equals` and `toString` - object instructions { - def fromMethod(meth: MethodNode): List[Instruction] = { - val insns = meth.instructions - val asmToScala = new AsmToScala{ def labelIndex(l: asm.tree.AbstractInsnNode) = insns.indexOf(l) } - - asmToScala.mapOver(insns.iterator.asScala.toList).asInstanceOf[List[Instruction]] +object ASMConverters { + + /** + * Transform the instructions of an ASM Method into a list of [[Instruction]]s. + */ + def instructionsFromMethod(meth: t.MethodNode): List[Instruction] = { + val insns = meth.instructions + val asmToScala = new AsmToScala { + def labelIndex(l: t.LabelNode) = insns.indexOf(l) } + asmToScala.convert(insns.iterator.asScala.toList) + } + + implicit class CompareInstructionLists(val self: List[Instruction]) { + def === (other: List[Instruction]) = equivalentBytecode(self, other) + } - sealed abstract class Instruction { def opcode: String } - case class Field (opcode: String, desc: String, name: String, owner: String) extends Instruction - case class Incr (opcode: String, incr: Int, `var`: Int) extends Instruction - case class Op (opcode: String) extends Instruction - case class IntOp (opcode: String, operand: Int) extends Instruction - case class Jump (opcode: String, label: Label) extends Instruction - case class Ldc (opcode: String, cst: Any) extends Instruction - case class LookupSwitch (opcode: String, dflt: Label, keys: List[Integer], labels: List[Label]) extends Instruction - case class TableSwitch (opcode: String, dflt: Label, max: Int, min: Int, labels: List[Label]) extends Instruction - case class Method (opcode: String, desc: String, name: String, owner: String) extends Instruction - case class NewArray (opcode: String, desc: String, dims: Int) extends Instruction - case class TypeOp (opcode: String, desc: String) extends Instruction - case class VarOp (opcode: String, `var`: Int) extends Instruction - case class Label (offset: Int) extends Instruction { def opcode: String = "" } - case class FrameEntry (local: List[Any], stack: List[Any]) extends Instruction { def opcode: String = "" } - case class LineNumber (line: Int, start: Label) extends Instruction { def opcode: String = "" } + sealed abstract class Instruction extends Product { + def opcode: Int + + // toString such that the first field, "opcode: Int", is printed textually. + final override def toString() = { + import scala.tools.asm.util.Printer.OPCODES + def opString(op: Int) = if (OPCODES.isDefinedAt(op)) OPCODES(op) else "?" + val printOpcode = opcode != -1 + + productPrefix + ( + if (printOpcode) Iterator(opString(opcode)) ++ productIterator.drop(1) + else productIterator + ).mkString("(", ", ", ")") + } } + case class Field (opcode: Int, owner: String, name: String, desc: String) extends Instruction + case class Incr (opcode: Int, `var`: Int, incr: Int) extends Instruction + case class Op (opcode: Int) extends Instruction + case class IntOp (opcode: Int, operand: Int) extends Instruction + case class Jump (opcode: Int, label: Label) extends Instruction + case class Ldc (opcode: Int, cst: Any) extends Instruction + case class LookupSwitch(opcode: Int, dflt: Label, keys: List[Int], labels: List[Label]) extends Instruction + case class TableSwitch (opcode: Int, min: Int, max: Int, dflt: Label, labels: List[Label]) extends Instruction + case class Method (opcode: Int, owner: String, name: String, desc: String, itf: Boolean) extends Instruction + case class NewArray (opcode: Int, desc: String, dims: Int) extends Instruction + case class TypeOp (opcode: Int, desc: String) extends Instruction + case class VarOp (opcode: Int, `var`: Int) extends Instruction + case class Label (offset: Int) extends Instruction { def opcode: Int = -1 } + case class FrameEntry (`type`: Int, local: List[Any], stack: List[Any]) extends Instruction { def opcode: Int = -1 } + case class LineNumber (line: Int, start: Label) extends Instruction { def opcode: Int = -1 } + abstract class AsmToScala { - import instructions._ - def labelIndex(l: asm.tree.AbstractInsnNode): Int + def labelIndex(l: t.LabelNode): Int - def mapOver(is: List[Any]): List[Any] = is map { - case i: asm.tree.AbstractInsnNode => apply(i) + def op(i: t.AbstractInsnNode): Int = i.getOpcode + + def convert(instructions: List[t.AbstractInsnNode]): List[Instruction] = instructions map apply + + private def lst[T](xs: java.util.List[T]): List[T] = if (xs == null) Nil else xs.asScala.toList + + // Heterogenous List[Any] is used in FrameNode: type information about locals / stack values + // are stored in a List[Any] (Integer, String or LabelNode), see Javadoc of MethodNode#visitFrame. + // Opcodes (eg Opcodes.INTEGER) and Reference types (eg "java/lang/Object") are returned unchanged, + // LabelNodes are mapped to their LabelEntry. + private def mapOverFrameTypes(is: List[Any]): List[Any] = is map { + case i: t.LabelNode => applyLabel(i) case x => x } - def op(i: asm.tree.AbstractInsnNode) = if (asm.util.Printer.OPCODES.isDefinedAt(i.getOpcode)) asm.util.Printer.OPCODES(i.getOpcode) else "?" - def lst[T](xs: java.util.List[T]): List[T] = if (xs == null) Nil else xs.asScala.toList - def apply(l: asm.tree.LabelNode): Label = this(l: asm.tree.AbstractInsnNode).asInstanceOf[Label] - def apply(x: asm.tree.AbstractInsnNode): Instruction = x match { - case i: asm.tree.FieldInsnNode => Field (op(i), i.desc: String, i.name: String, i.owner: String) - case i: asm.tree.IincInsnNode => Incr (op(i), i.incr: Int, i.`var`: Int) - case i: asm.tree.InsnNode => Op (op(i)) - case i: asm.tree.IntInsnNode => IntOp (op(i), i.operand: Int) - case i: asm.tree.JumpInsnNode => Jump (op(i), this(i.label)) - case i: asm.tree.LdcInsnNode => Ldc (op(i), i.cst: Any) - case i: asm.tree.LookupSwitchInsnNode => LookupSwitch (op(i), this(i.dflt), lst(i.keys), mapOver(lst(i.labels)).asInstanceOf[List[Label]]) - case i: asm.tree.TableSwitchInsnNode => TableSwitch (op(i), this(i.dflt), i.max: Int, i.min: Int, mapOver(lst(i.labels)).asInstanceOf[List[Label]]) - case i: asm.tree.MethodInsnNode => Method (op(i), i.desc: String, i.name: String, i.owner: String) - case i: asm.tree.MultiANewArrayInsnNode => NewArray (op(i), i.desc: String, i.dims: Int) - case i: asm.tree.TypeInsnNode => TypeOp (op(i), i.desc: String) - case i: asm.tree.VarInsnNode => VarOp (op(i), i.`var`: Int) - case i: asm.tree.LabelNode => Label (labelIndex(x)) - case i: asm.tree.FrameNode => FrameEntry (mapOver(lst(i.local)), mapOver(lst(i.stack))) - case i: asm.tree.LineNumberNode => LineNumber (i.line: Int, this(i.start): Label) + // avoids some casts + private def applyLabel(l: t.LabelNode) = this(l: t.AbstractInsnNode).asInstanceOf[Label] + + private def apply(x: t.AbstractInsnNode): Instruction = x match { + case i: t.FieldInsnNode => Field (op(i), i.owner, i.name, i.desc) + case i: t.IincInsnNode => Incr (op(i), i.`var`, i.incr) + case i: t.InsnNode => Op (op(i)) + case i: t.IntInsnNode => IntOp (op(i), i.operand) + case i: t.JumpInsnNode => Jump (op(i), applyLabel(i.label)) + case i: t.LdcInsnNode => Ldc (op(i), i.cst: Any) + case i: t.LookupSwitchInsnNode => LookupSwitch (op(i), applyLabel(i.dflt), lst(i.keys) map (x => x: Int), lst(i.labels) map applyLabel) + case i: t.TableSwitchInsnNode => TableSwitch (op(i), i.min, i.max, applyLabel(i.dflt), lst(i.labels) map applyLabel) + case i: t.MethodInsnNode => Method (op(i), i.desc, i.name, i.owner, i.itf) + case i: t.MultiANewArrayInsnNode => NewArray (op(i), i.desc, i.dims) + case i: t.TypeInsnNode => TypeOp (op(i), i.desc) + case i: t.VarInsnNode => VarOp (op(i), i.`var`) + case i: t.LabelNode => Label (labelIndex(i)) + case i: t.FrameNode => FrameEntry (i.`type`, mapOverFrameTypes(lst(i.local)), mapOverFrameTypes(lst(i.stack))) + case i: t.LineNumberNode => LineNumber (i.line, applyLabel(i.start)) + } + } + + import collection.mutable.{Map => MMap} + + /** + * Bytecode is equal modula local variable numbering and label numbering. + */ + def equivalentBytecode(as: List[Instruction], bs: List[Instruction], varMap: MMap[Int, Int] = MMap(), labelMap: MMap[Int, Int] = MMap()): Boolean = { + def same(v1: Int, v2: Int, m: MMap[Int, Int]) = { + if (m contains v1) m(v1) == v2 + else if (m.valuesIterator contains v2) false // v2 is already associated with some different value v1 + else { m(v1) = v2; true } } + def sameVar(v1: Int, v2: Int) = same(v1, v2, varMap) + def sameLabel(l1: Label, l2: Label) = same(l1.offset, l2.offset, labelMap) + def sameLabels(ls1: List[Label], ls2: List[Label]) = ls1.length == ls2.length && (ls1, ls2).zipped.forall(sameLabel) + + def sameFrameTypes(ts1: List[Any], ts2: List[Any]) = ts1.length == ts2.length && (ts1, ts2).zipped.forall { + case (t1: Label, t2: Label) => sameLabel(t1, t2) + case (x, y) => x == y + } + + if (as.isEmpty) bs.isEmpty + else if (bs.isEmpty) false + else ((as.head, bs.head) match { + case (VarOp(op1, v1), VarOp(op2, v2)) => op1 == op2 && sameVar(v1, v2) + case (Incr(op1, v1, inc1), Incr(op2, v2, inc2)) => op1 == op2 && sameVar(v1, v2) && inc1 == inc2 + + case (l1 @ Label(_), l2 @ Label(_)) => sameLabel(l1, l2) + case (Jump(op1, l1), Jump(op2, l2)) => op1 == op2 && sameLabel(l1, l2) + case (LookupSwitch(op1, l1, keys1, ls1), LookupSwitch(op2, l2, keys2, ls2)) => op1 == op2 && sameLabel(l1, l2) && keys1 == keys2 && sameLabels(ls1, ls2) + case (TableSwitch(op1, min1, max1, l1, ls1), TableSwitch(op2, min2, max2, l2, ls2)) => op1 == op2 && min1 == min2 && max1 == max2 && sameLabel(l1, l2) && sameLabels(ls1, ls2) + case (LineNumber(line1, l1), LineNumber(line2, l2)) => line1 == line2 && sameLabel(l1, l2) + case (FrameEntry(tp1, loc1, stk1), FrameEntry(tp2, loc2, stk2)) => tp1 == tp2 && sameFrameTypes(loc1, loc2) && sameFrameTypes(stk1, stk2) + + // this needs to go after the above. For example, Label(1) may not equal Label(1), if before + // the left 1 was associated with another right index. + case (a, b) if a == b => true + + case _ => false + }) && equivalentBytecode(as.tail, bs.tail, varMap, labelMap) + } + + /** + * Convert back a list of [[Instruction]]s to ASM land. The code is emitted into the parameter + * `method`. + */ + def applyToMethod(method: t.MethodNode, instructions: List[Instruction]): Unit = { + val asmLabel = createLabelNodes(instructions) + instructions.foreach(visitMethod(method, _, asmLabel)) + } + + private def createLabelNodes(instructions: List[Instruction]): Map[Label, asm.Label] = { + val labels = instructions collect { + case l: Label => l + } + assert(labels.distinct == labels, s"Duplicate labels in: $labels") + labels.map(l => (l, new asm.Label())).toMap + } + + private def frameTypesToAsm(l: List[Any], asmLabel: Map[Label, asm.Label]): List[Object] = l map { + case l: Label => asmLabel(l) + case x => x.asInstanceOf[Object] + } + + private def visitMethod(method: t.MethodNode, instruction: Instruction, asmLabel: Map[Label, asm.Label]): Unit = instruction match { + case Field(op, owner, name, desc) => method.visitFieldInsn(op, owner, name, desc) + case Incr(op, vr, incr) => method.visitIincInsn(vr, incr) + case Op(op) => method.visitInsn(op) + case IntOp(op, operand) => method.visitIntInsn(op, operand) + case Jump(op, label) => method.visitJumpInsn(op, asmLabel(label)) + case Ldc(op, cst) => method.visitLdcInsn(cst) + case LookupSwitch(op, dflt, keys, labels) => method.visitLookupSwitchInsn(asmLabel(dflt), keys.toArray, (labels map asmLabel).toArray) + case TableSwitch(op, min, max, dflt, labels) => method.visitTableSwitchInsn(min, max, asmLabel(dflt), (labels map asmLabel).toArray: _*) + case Method(op, owner, name, desc, itf) => method.visitMethodInsn(op, owner, name, desc, itf) + case NewArray(op, desc, dims) => method.visitMultiANewArrayInsn(desc, dims) + case TypeOp(op, desc) => method.visitTypeInsn(op, desc) + case VarOp(op, vr) => method.visitVarInsn(op, vr) + case l: Label => method.visitLabel(asmLabel(l)) + case FrameEntry(tp, local, stack) => method.visitFrame(tp, local.length, frameTypesToAsm(local, asmLabel).toArray, stack.length, frameTypesToAsm(stack, asmLabel).toArray) + case LineNumber(line, start) => method.visitLineNumber(line, asmLabel(start)) } -} \ No newline at end of file +} diff --git a/src/partest-extras/scala/tools/partest/BytecodeTest.scala b/src/partest-extras/scala/tools/partest/BytecodeTest.scala index 1e4362fcde73..c6fa279c5041 100644 --- a/src/partest-extras/scala/tools/partest/BytecodeTest.scala +++ b/src/partest-extras/scala/tools/partest/BytecodeTest.scala @@ -3,7 +3,7 @@ package scala.tools.partest import scala.tools.nsc.util.JavaClassPath import scala.collection.JavaConverters._ import scala.tools.asm.{ClassWriter, ClassReader} -import scala.tools.asm.tree.{ClassNode, MethodNode, InsnList} +import scala.tools.asm.tree._ import java.io.{FileOutputStream, FileInputStream, File => JFile, InputStream} import AsmNode._ @@ -28,8 +28,8 @@ import AsmNode._ * See test/files/jvm/bytecode-test-example for an example of bytecode test. * */ -abstract class BytecodeTest extends ASMConverters { - import instructions._ +abstract class BytecodeTest { + import ASMConverters._ /** produce the output to be compared against a checkfile */ protected def show(): Unit @@ -38,8 +38,8 @@ abstract class BytecodeTest extends ASMConverters { // asserts def sameBytecode(methA: MethodNode, methB: MethodNode) = { - val isa = instructions.fromMethod(methA) - val isb = instructions.fromMethod(methB) + val isa = instructionsFromMethod(methA) + val isb = instructionsFromMethod(methB) if (isa == isb) println("bytecode identical") else diffInstructions(isa, isb) } @@ -81,18 +81,16 @@ abstract class BytecodeTest extends ASMConverters { } } - // bytecode is equal modulo local variable numbering - def equalsModuloVar(a: Instruction, b: Instruction) = (a, b) match { - case _ if a == b => true - case (VarOp(op1, _), VarOp(op2, _)) if op1 == op2 => true - case _ => false - } - - def similarBytecode(methA: MethodNode, methB: MethodNode, similar: (Instruction, Instruction) => Boolean) = { - val isa = fromMethod(methA) - val isb = fromMethod(methB) + /** + * Compare the bytecodes of two methods. + * + * The for the `similar` function, you probably want to pass [[ASMConverters.equivalentBytecode]]. + */ + def similarBytecode(methA: MethodNode, methB: MethodNode, similar: (List[Instruction], List[Instruction]) => Boolean) = { + val isa = instructionsFromMethod(methA) + val isb = instructionsFromMethod(methB) if (isa == isb) println("bytecode identical") - else if ((isa, isb).zipped.forall { case (a, b) => similar(a, b) }) println("bytecode similar") + else if (similar(isa, isb)) println("bytecode similar") else diffInstructions(isa, isb) } diff --git a/test/files/jvm/t6941/test.scala b/test/files/jvm/t6941/test.scala index 248617f71f02..fceb54487fa6 100644 --- a/test/files/jvm/t6941/test.scala +++ b/test/files/jvm/t6941/test.scala @@ -1,4 +1,4 @@ -import scala.tools.partest.BytecodeTest +import scala.tools.partest.{BytecodeTest, ASMConverters} import scala.tools.nsc.util.JavaClassPath import java.io.InputStream @@ -10,6 +10,6 @@ import scala.collection.JavaConverters._ object Test extends BytecodeTest { def show: Unit = { val classNode = loadClassNode("SameBytecode") - similarBytecode(getMethod(classNode, "a"), getMethod(classNode, "b"), equalsModuloVar) + similarBytecode(getMethod(classNode, "a"), getMethod(classNode, "b"), ASMConverters.equivalentBytecode(_, _)) } } diff --git a/test/files/jvm/t7253/test.scala b/test/files/jvm/t7253/test.scala index 7fe08e881375..a3f1e86e6526 100644 --- a/test/files/jvm/t7253/test.scala +++ b/test/files/jvm/t7253/test.scala @@ -1,4 +1,4 @@ -import scala.tools.partest.BytecodeTest +import scala.tools.partest.{BytecodeTest, ASMConverters} import scala.tools.nsc.util.JavaClassPath import java.io.InputStream @@ -8,10 +8,10 @@ import asm.tree.{ClassNode, InsnList} import scala.collection.JavaConverters._ object Test extends BytecodeTest { - import instructions._ + import ASMConverters._ def show: Unit = { - val instrBaseSeqs = Seq("ScalaClient_1", "JavaClient_1") map (name => instructions.fromMethod(getMethod(loadClassNode(name), "foo"))) + val instrBaseSeqs = Seq("ScalaClient_1", "JavaClient_1") map (name => instructionsFromMethod(getMethod(loadClassNode(name), "foo"))) val instrSeqs = instrBaseSeqs map (_ filter isInvoke) cmpInstructions(instrSeqs(0), instrSeqs(1)) } diff --git a/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala b/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala index cb7e7050b027..221aad653679 100644 --- a/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala +++ b/test/junit/scala/tools/nsc/backend/jvm/BTypesTest.scala @@ -1,7 +1,6 @@ package scala.tools.nsc package backend.jvm -import scala.tools.testing.AssertUtil._ import org.junit.runner.RunWith import org.junit.runners.JUnit4 import org.junit.Test diff --git a/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala b/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala new file mode 100644 index 000000000000..256dff85c347 --- /dev/null +++ b/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala @@ -0,0 +1,27 @@ +package scala.tools.nsc.backend.jvm + +import scala.tools.asm.Opcodes +import scala.tools.asm.tree.{AbstractInsnNode, LabelNode, ClassNode, MethodNode} +import scala.tools.partest.ASMConverters +import scala.collection.JavaConverters._ + +object CodeGenTools { + import ASMConverters._ + + def genMethod( flags: Int = Opcodes.ACC_PUBLIC, + name: String = "m", + descriptor: String = "()V", + genericSignature: String = null, + throwsExceptions: Array[String] = null)(body: Instruction*): MethodNode = { + val node = new MethodNode(flags, name, descriptor, genericSignature, throwsExceptions) + applyToMethod(node, body.toList) + node + } + + def wrapInClass(method: MethodNode): ClassNode = { + val cls = new ClassNode() + cls.visit(Opcodes.V1_6, Opcodes.ACC_PUBLIC, "C", null, "java/lang/Object", null) + cls.methods.add(method) + cls + } +} diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala new file mode 100644 index 000000000000..4e62cc64e43d --- /dev/null +++ b/test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala @@ -0,0 +1,162 @@ +package scala.tools.nsc +package backend.jvm +package opt + +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 +import org.junit.Test +import scala.tools.asm.Opcodes._ +import org.junit.Assert._ + +import scala.tools.testing.AssertUtil._ + +import CodeGenTools._ +import scala.tools.partest.ASMConverters +import ASMConverters._ + +@RunWith(classOf[JUnit4]) +class UnreachableCodeTest { + import UnreachableCodeTest._ + + @Test + def basicElimination(): Unit = { + assertEliminateDead( + Op(ACONST_NULL), + Op(ATHROW), + Op(RETURN).dead + ) + + assertEliminateDead( + Op(RETURN) + ) + + assertEliminateDead( + Op(RETURN), + Op(ACONST_NULL).dead, + Op(ATHROW).dead + ) + } + + @Test + def eliminateNop(): Unit = { + assertEliminateDead( + // not dead, since visited by data flow analysis. need a different opt to eliminate it. + Op(NOP), + Op(RETURN), + Op(NOP).dead + ) + } + + @Test + def eliminateBranchOver(): Unit = { + assertEliminateDead( + Jump(GOTO, Label(1)), + Op(ACONST_NULL).dead, + Op(ATHROW).dead, + Label(1), + Op(RETURN) + ) + + assertEliminateDead( + Jump(GOTO, Label(1)), + Label(1), + Op(RETURN) + ) + } + + @Test + def deadLabelsRemain(): Unit = { + assertEliminateDead( + Op(RETURN), + Jump(GOTO, Label(1)).dead, + // not dead - labels may be referenced from other places in a classfile (eg exceptions table). + // will need a different opt to get rid of them + Label(1) + ) + } + + @Test + def pushPopNotEliminated(): Unit = { + assertEliminateDead( + // not dead, visited by data flow analysis. + Op(ACONST_NULL), + Op(POP), + Op(RETURN) + ) + } + + @Test + def nullnessNotConsidered(): Unit = { + assertEliminateDead( + Op(ACONST_NULL), + Jump(IFNULL, Label(1)), + Op(RETURN), // not dead + Label(1), + Op(RETURN) + ) + } + + @Test + def metaTest(): Unit = { + assertEliminateDead() // no instructions + + assertThrows[AssertionError]( + assertEliminateDead(Op(RETURN).dead), + _.contains("Expected: List()\nActual : List(Op(RETURN))") + ) + + assertThrows[AssertionError]( + assertEliminateDead(Op(RETURN), Op(RETURN)), + _.contains("Expected: List(Op(RETURN), Op(RETURN))\nActual : List(Op(RETURN))") + ) + } + + @Test + def bytecodeEquivalence: Unit = { + assertTrue(List(VarOp(ILOAD, 1)) === + List(VarOp(ILOAD, 2))) + assertTrue(List(VarOp(ILOAD, 1), VarOp(ISTORE, 1)) === + List(VarOp(ILOAD, 2), VarOp(ISTORE, 2))) + + // the first Op will associate 1->2, then the 2->2 will fail + assertFalse(List(VarOp(ILOAD, 1), VarOp(ISTORE, 2)) === + List(VarOp(ILOAD, 2), VarOp(ISTORE, 2))) + + // will associate 1->2 and 2->1, which is OK + assertTrue(List(VarOp(ILOAD, 1), VarOp(ISTORE, 2)) === + List(VarOp(ILOAD, 2), VarOp(ISTORE, 1))) + + assertTrue(List(Label(1), Label(2), Label(1)) === + List(Label(2), Label(4), Label(2))) + assertTrue(List(LineNumber(1, Label(1)), Label(1)) === + List(LineNumber(1, Label(3)), Label(3))) + assertFalse(List(LineNumber(1, Label(1)), Label(1)) === + List(LineNumber(1, Label(3)), Label(1))) + + assertTrue(List(TableSwitch(TABLESWITCH, 1, 3, Label(4), List(Label(5), Label(6))), Label(4), Label(5), Label(6)) === + List(TableSwitch(TABLESWITCH, 1, 3, Label(9), List(Label(3), Label(4))), Label(9), Label(3), Label(4))) + + assertTrue(List(FrameEntry(F_FULL, List(INTEGER, DOUBLE, Label(3)), List("java/lang/Object", Label(4))), Label(3), Label(4)) === + List(FrameEntry(F_FULL, List(INTEGER, DOUBLE, Label(1)), List("java/lang/Object", Label(3))), Label(1), Label(3))) + } +} + +object UnreachableCodeTest { + import scala.language.implicitConversions + implicit def aliveInstruction(ins: Instruction): (Instruction, Boolean) = (ins, true) + + implicit class MortalInstruction(val ins: Instruction) extends AnyVal { + def dead: (Instruction, Boolean) = (ins, false) + } + + def assertEliminateDead(code: (Instruction, Boolean)*): Unit = { + val cls = wrapInClass(genMethod()(code.map(_._1): _*)) + LocalOpt.removeUnreachableCode(cls) + val nonEliminated = instructionsFromMethod(cls.methods.get(0)) + + val expectedLive = code.filter(_._2).map(_._1).toList + + assertTrue(s"\nExpected: $expectedLive\nActual : $nonEliminated", nonEliminated === expectedLive) + } + +} diff --git a/test/junit/scala/tools/testing/AssertThrowsTest.scala b/test/junit/scala/tools/testing/AssertThrowsTest.scala index a70519e63c68..d91e450bac99 100644 --- a/test/junit/scala/tools/testing/AssertThrowsTest.scala +++ b/test/junit/scala/tools/testing/AssertThrowsTest.scala @@ -31,4 +31,13 @@ class AssertThrowsTest { } }) -} \ No newline at end of file + @Test + def errorIfNoThrow: Unit = { + try { + assertThrows[Foo] { () } + } catch { + case e: AssertionError => return + } + assert(false, "assertThrows should error if the tested expression does not throw anything") + } +} From 35c53af7e3bbe19d50845e698c02a49d0a022409 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Wed, 27 Aug 2014 14:00:36 +0200 Subject: [PATCH 535/826] Tools to run the compiler in JUnit tests --- .../scala/tools/partest/ASMConverters.scala | 23 +++++- .../tools/nsc/backend/jvm/CodeGenTools.scala | 34 ++++++++ .../nsc/backend/jvm/DirectCompileTest.scala | 81 +++++++++++++++++++ 3 files changed, 136 insertions(+), 2 deletions(-) create mode 100644 test/junit/scala/tools/nsc/backend/jvm/DirectCompileTest.scala diff --git a/src/partest-extras/scala/tools/partest/ASMConverters.scala b/src/partest-extras/scala/tools/partest/ASMConverters.scala index 50057d058c45..f4a90d9acf99 100644 --- a/src/partest-extras/scala/tools/partest/ASMConverters.scala +++ b/src/partest-extras/scala/tools/partest/ASMConverters.scala @@ -3,6 +3,7 @@ package scala.tools.partest import scala.collection.JavaConverters._ import scala.tools.asm import asm.{tree => t} +import scala.tools.asm.tree.LabelNode /** Makes using ASM from ByteCodeTests more convenient. * @@ -22,8 +23,26 @@ object ASMConverters { asmToScala.convert(insns.iterator.asScala.toList) } - implicit class CompareInstructionLists(val self: List[Instruction]) { + implicit class RichInstructionLists(val self: List[Instruction]) extends AnyVal { def === (other: List[Instruction]) = equivalentBytecode(self, other) + + def dropLinesFrames = self.filterNot(i => i.isInstanceOf[LineNumber] || i.isInstanceOf[FrameEntry]) + + private def referencedLabels(instruction: Instruction): Set[Instruction] = instruction match { + case Jump(op, label) => Set(label) + case LookupSwitch(op, dflt, keys, labels) => (dflt :: labels).toSet + case TableSwitch(op, min, max, dflt, labels) => (dflt :: labels).toSet + case LineNumber(line, start) => Set(start) + case _ => Set.empty + } + + def dropStaleLabels = { + val definedLabels: Set[Instruction] = self.filter(_.isInstanceOf[Label]).toSet + val usedLabels: Set[Instruction] = self.flatMap(referencedLabels)(collection.breakOut) + self.filterNot(definedLabels diff usedLabels) + } + + def dropNonOp = dropLinesFrames.dropStaleLabels } sealed abstract class Instruction extends Product { @@ -89,7 +108,7 @@ object ASMConverters { case i: t.LdcInsnNode => Ldc (op(i), i.cst: Any) case i: t.LookupSwitchInsnNode => LookupSwitch (op(i), applyLabel(i.dflt), lst(i.keys) map (x => x: Int), lst(i.labels) map applyLabel) case i: t.TableSwitchInsnNode => TableSwitch (op(i), i.min, i.max, applyLabel(i.dflt), lst(i.labels) map applyLabel) - case i: t.MethodInsnNode => Method (op(i), i.desc, i.name, i.owner, i.itf) + case i: t.MethodInsnNode => Method (op(i), i.owner, i.name, i.desc, i.itf) case i: t.MultiANewArrayInsnNode => NewArray (op(i), i.desc, i.dims) case i: t.TypeInsnNode => TypeOp (op(i), i.desc) case i: t.VarInsnNode => VarOp (op(i), i.`var`) diff --git a/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala b/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala index 256dff85c347..8518d5c832fb 100644 --- a/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala +++ b/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala @@ -1,7 +1,11 @@ package scala.tools.nsc.backend.jvm +import scala.reflect.internal.util.BatchSourceFile +import scala.reflect.io.VirtualDirectory import scala.tools.asm.Opcodes import scala.tools.asm.tree.{AbstractInsnNode, LabelNode, ClassNode, MethodNode} +import scala.tools.cmd.CommandLineParser +import scala.tools.nsc.{Settings, Global} import scala.tools.partest.ASMConverters import scala.collection.JavaConverters._ @@ -24,4 +28,34 @@ object CodeGenTools { cls.methods.add(method) cls } + + private def resetOutput(compiler: Global): Unit = { + compiler.settings.outputDirs.setSingleOutput(new VirtualDirectory("(memory)", None)) + } + + def newCompiler(defaultArgs: String = "-usejavacp", extraArgs: String = ""): Global = { + val settings = new Settings() + val args = (CommandLineParser tokenize defaultArgs) ++ (CommandLineParser tokenize extraArgs) + settings.processArguments(args, processAll = true) + val compiler = new Global(settings) + resetOutput(compiler) + compiler + } + + def compile(compiler: Global = newCompiler())(code: String): List[(String, Array[Byte])] = { + compiler.reporter.reset() + resetOutput(compiler) + val run = new compiler.Run() + run.compileSources(List(new BatchSourceFile("unitTestSource.scala", code))) + val outDir = compiler.settings.outputDirs.getSingleOutput.get + (for (f <- outDir.iterator if !f.isDirectory) yield (f.name, f.toByteArray)).toList + } + + def compileClasses(compiler: Global = newCompiler())(code: String): List[ClassNode] = { + compile(compiler)(code).map(p => AsmUtils.readClass(p._2)).sortBy(_.name) + } + + def compileMethods(compiler: Global = newCompiler())(code: String): List[MethodNode] = { + compileClasses(compiler)(s"class C { $code }").head.methods.asScala.toList.filterNot(_.name == "") + } } diff --git a/test/junit/scala/tools/nsc/backend/jvm/DirectCompileTest.scala b/test/junit/scala/tools/nsc/backend/jvm/DirectCompileTest.scala new file mode 100644 index 000000000000..640f22fc4792 --- /dev/null +++ b/test/junit/scala/tools/nsc/backend/jvm/DirectCompileTest.scala @@ -0,0 +1,81 @@ +package scala.tools.nsc.backend.jvm + +import org.junit.Test +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 +import org.junit.Assert._ +import CodeGenTools._ +import scala.tools.asm.Opcodes._ +import scala.tools.partest.ASMConverters._ + +@RunWith(classOf[JUnit4]) +class DirectCompileTest { + val compiler = newCompiler(extraArgs = "-Ybackend:GenBCode") + + @Test + def testCompile(): Unit = { + val List(("C.class", bytes)) = compile(compiler)( + """ + |class C { + | def f = 1 + |} + """.stripMargin) + def s(i: Int, n: Int) = (bytes(i) & 0xff) << n + assertTrue((s(0, 24) | s(1, 16) | s(2, 8) | s(3, 0)) == 0xcafebabe) // mocha java latte machiatto surpreme dark roasted espresso + } + + @Test + def testCompileClasses(): Unit = { + val List(cClass, cModuleClass) = compileClasses(compiler)( + """ + |class C + |object C + """.stripMargin) + + assertTrue(cClass.name == "C") + assertTrue(cModuleClass.name == "C$") + + val List(dMirror, dModuleClass) = compileClasses(compiler)( + """ + |object D + """.stripMargin) + + assertTrue(dMirror.name == "D") + assertTrue(dModuleClass.name == "D$") + } + + @Test + def testCompileMethods(): Unit = { + val List(f, g) = compileMethods(compiler)( + """ + |def f = 10 + |def g = f + """.stripMargin) + assertTrue(f.name == "f") + assertTrue(g.name == "g") + + assertTrue(instructionsFromMethod(f).dropNonOp === + List(IntOp(BIPUSH, 10), Op(IRETURN))) + + assertTrue(instructionsFromMethod(g).dropNonOp === + List(VarOp(ALOAD, 0), Method(INVOKEVIRTUAL, "C", "f", "()I", false), Op(IRETURN))) + } + + @Test + def testDropNonOpAliveLabels(): Unit = { + val List(f) = compileMethods(compiler)("""def f(x: Int) = if (x == 0) "a" else "b"""") + assertTrue(instructionsFromMethod(f).dropNonOp === List( + VarOp(ILOAD, 1), + Op(ICONST_0), + Jump(IF_ICMPEQ, Label(6)), + Jump(GOTO, Label(10)), + Label(6), + Ldc(LDC, "a"), + Jump(GOTO, Label(13)), + Label(10), + Ldc(LDC, "b"), + Label(13), + Op(ARETURN) + )) + } +} From 630bd29f9e92ad26b8ce05835e2edc115633072c Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 28 Aug 2014 15:47:07 +0200 Subject: [PATCH 536/826] Clarify why we emit ATHROW after expressions of type Nothing Tests for emitting expressions of type Nothing. --- .../nsc/backend/jvm/BCodeBodyBuilder.scala | 46 +++++++++++++- test/files/run/nothingTypeDce.flags | 1 + test/files/run/nothingTypeDce.scala | 61 +++++++++++++++++++ test/files/run/nothingTypeNoFramesNoDce.check | 1 + test/files/run/nothingTypeNoFramesNoDce.flags | 1 + test/files/run/nothingTypeNoFramesNoDce.scala | 61 +++++++++++++++++++ test/files/run/nothingTypeNoOpt.flags | 1 + test/files/run/nothingTypeNoOpt.scala | 61 +++++++++++++++++++ .../tools/nsc/backend/jvm/CodeGenTools.scala | 11 +++- .../backend/jvm/opt/UnreachableCodeTest.scala | 45 +++++++++++++- 10 files changed, 282 insertions(+), 7 deletions(-) create mode 100644 test/files/run/nothingTypeDce.flags create mode 100644 test/files/run/nothingTypeDce.scala create mode 100644 test/files/run/nothingTypeNoFramesNoDce.check create mode 100644 test/files/run/nothingTypeNoFramesNoDce.flags create mode 100644 test/files/run/nothingTypeNoFramesNoDce.scala create mode 100644 test/files/run/nothingTypeNoOpt.flags create mode 100644 test/files/run/nothingTypeNoOpt.scala diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index d71d71362eb8..68b6f1af37cd 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -814,7 +814,51 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { case _ => bc.emitT2T(from, to) } } else if (from.isNothingType) { - emit(asm.Opcodes.ATHROW) // ICode enters here into enterIgnoreMode, we'll rely instead on DCE at ClassNode level. + /* There are two possibilities for from.isNothingType: emitting a "throw e" expressions and + * loading a (phantom) value of type Nothing. + * + * The Nothing type in Scala's type system does not exist in the JVM. In bytecode, Nothing + * is mapped to scala.runtime.Nothing$. To the JVM, a call to Predef.??? looks like it would + * return an object of type Nothing$. We need to do something with that phantom object on + * the stack. "Phantom" because it never exists: such methods always throw, but the JVM does + * not know that. + * + * Note: The two verifiers (old: type inference, new: type checking) have differnet + * requirements. Very briefly: + * + * Old (http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.10.2.1): at + * each program point, no matter what branches were taken to get there + * - Stack is same size and has same typed values + * - Local and stack values need to have consistent types + * - In practice, the old verifier seems to ignore unreachable code and accept any + * instrucitons after an ATHROW. For example, there can be another ATHROW (without + * loading another throwable first). + * + * New (http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.10.1) + * - Requires consistent stack map frames. GenBCode generates stack frames if -target:jvm-1.6 + * or higher. + * - In practice: the ASM library computes stack map frames for us (ClassWriter). Emitting + * correct frames after an ATHROW is probably complex, so ASM uses the following strategy: + * - Every time when generating an ATHROW, a new basic block is started. + * - During classfile writing, such basic blocks are found to be dead: no branches go there + * - Eliminating dead code would probably require complex shifts in the output byte buffer + * - But there's an easy solution: replace all code in the dead block with with + * `nop; nop; ... nop; athrow`, making sure the bytecode size stays the same + * - The corresponding stack frame can be easily generated: on entering a dead the block, + * the frame requires a single Throwable on the stack. + * - Since there are no branches to the dead block, the frame requirements are never violated. + * + * To summarize the above: it does matter what we emit after an ATHROW. + * + * NOW: if we end up here because we emitted a load of a (phantom) value of type Nothing$, + * there was no ATHROW emitted. So, we have to make the verifier happy and do something + * with that value. Since Nothing$ extends Throwable, the easiest is to just emit an ATHROW. + * + * If we ended up here because we generated a "throw e" expression, we know the last + * emitted instruction was an ATHROW. As explained above, it is OK to emit a second ATHROW, + * the verifiers will be happy. + */ + emit(asm.Opcodes.ATHROW) } else if (from.isNullType) { bc drop from emit(asm.Opcodes.ACONST_NULL) diff --git a/test/files/run/nothingTypeDce.flags b/test/files/run/nothingTypeDce.flags new file mode 100644 index 000000000000..d85321ca0eaa --- /dev/null +++ b/test/files/run/nothingTypeDce.flags @@ -0,0 +1 @@ +-target:jvm-1.6 -Ybackend:GenBCode -Yopt:unreachable-code diff --git a/test/files/run/nothingTypeDce.scala b/test/files/run/nothingTypeDce.scala new file mode 100644 index 000000000000..4b9d934eacf0 --- /dev/null +++ b/test/files/run/nothingTypeDce.scala @@ -0,0 +1,61 @@ +// See comment in BCodeBodyBuilder + +// -target:jvm-1.6 -Ybackend:GenBCode -Yopt:unreachable-code +// target enables stack map frames generation + +class C { + // can't just emit a call to ???, that returns value of type Nothing$ (not Int). + def f1: Int = ??? + + def f2: Int = throw new Error("") + + def f3(x: Boolean) = { + var y = 0 + // cannot assign an object of type Nothing$ to Int + if (x) y = ??? + else y = 1 + y + } + + def f4(x: Boolean) = { + var y = 0 + // tests that whatever is emitted after the throw is valid (what? depends on opts, presence of stack map frames) + if (x) y = throw new Error("") + else y = 1 + y + } + + def f5(x: Boolean) = { + // stack heights need to be the smae. ??? looks to the jvm like returning a value of + // type Nothing$, need to drop or throw it. + println( + if (x) { ???; 10 } + else 20 + ) + } + + def f6(x: Boolean) = { + println( + if (x) { throw new Error(""); 10 } + else 20 + ) + } + + def f7(x: Boolean) = { + println( + if (x) throw new Error("") + else 20 + ) + } + + def f8(x: Boolean) = { + println( + if (x) throw new Error("") + else 20 + ) + } +} + +object Test extends App { + new C() +} diff --git a/test/files/run/nothingTypeNoFramesNoDce.check b/test/files/run/nothingTypeNoFramesNoDce.check new file mode 100644 index 000000000000..b1d08b45ffef --- /dev/null +++ b/test/files/run/nothingTypeNoFramesNoDce.check @@ -0,0 +1 @@ +warning: -target:jvm-1.5 is deprecated: use target for Java 1.6 or above. diff --git a/test/files/run/nothingTypeNoFramesNoDce.flags b/test/files/run/nothingTypeNoFramesNoDce.flags new file mode 100644 index 000000000000..a035c861798f --- /dev/null +++ b/test/files/run/nothingTypeNoFramesNoDce.flags @@ -0,0 +1 @@ +-target:jvm-1.5 -Ybackend:GenBCode -Yopt:l:none -deprecation diff --git a/test/files/run/nothingTypeNoFramesNoDce.scala b/test/files/run/nothingTypeNoFramesNoDce.scala new file mode 100644 index 000000000000..3d1298303aaa --- /dev/null +++ b/test/files/run/nothingTypeNoFramesNoDce.scala @@ -0,0 +1,61 @@ +// See comment in BCodeBodyBuilder + +// -target:jvm-1.5 -Ybackend:GenBCode -Yopt:l:none +// target disables stack map frame generation. in this mode, the ClssWriter just emits dead code as is. + +class C { + // can't just emit a call to ???, that returns value of type Nothing$ (not Int). + def f1: Int = ??? + + def f2: Int = throw new Error("") + + def f3(x: Boolean) = { + var y = 0 + // cannot assign an object of type Nothing$ to Int + if (x) y = ??? + else y = 1 + y + } + + def f4(x: Boolean) = { + var y = 0 + // tests that whatever is emitted after the throw is valid (what? depends on opts, presence of stack map frames) + if (x) y = throw new Error("") + else y = 1 + y + } + + def f5(x: Boolean) = { + // stack heights need to be the smae. ??? looks to the jvm like returning a value of + // type Nothing$, need to drop or throw it. + println( + if (x) { ???; 10 } + else 20 + ) + } + + def f6(x: Boolean) = { + println( + if (x) { throw new Error(""); 10 } + else 20 + ) + } + + def f7(x: Boolean) = { + println( + if (x) throw new Error("") + else 20 + ) + } + + def f8(x: Boolean) = { + println( + if (x) throw new Error("") + else 20 + ) + } +} + +object Test extends App { + new C() +} diff --git a/test/files/run/nothingTypeNoOpt.flags b/test/files/run/nothingTypeNoOpt.flags new file mode 100644 index 000000000000..b3b518051b6f --- /dev/null +++ b/test/files/run/nothingTypeNoOpt.flags @@ -0,0 +1 @@ +-target:jvm-1.6 -Ybackend:GenBCode -Yopt:l:none diff --git a/test/files/run/nothingTypeNoOpt.scala b/test/files/run/nothingTypeNoOpt.scala new file mode 100644 index 000000000000..5c5a20fa3b61 --- /dev/null +++ b/test/files/run/nothingTypeNoOpt.scala @@ -0,0 +1,61 @@ +// See comment in BCodeBodyBuilder + +// -target:jvm-1.6 -Ybackend:GenBCode -Yopt:l:none +// target enables stack map frame generation + +class C { + // can't just emit a call to ???, that returns value of type Nothing$ (not Int). + def f1: Int = ??? + + def f2: Int = throw new Error("") + + def f3(x: Boolean) = { + var y = 0 + // cannot assign an object of type Nothing$ to Int + if (x) y = ??? + else y = 1 + y + } + + def f4(x: Boolean) = { + var y = 0 + // tests that whatever is emitted after the throw is valid (what? depends on opts, presence of stack map frames) + if (x) y = throw new Error("") + else y = 1 + y + } + + def f5(x: Boolean) = { + // stack heights need to be the smae. ??? looks to the jvm like returning a value of + // type Nothing$, need to drop or throw it. + println( + if (x) { ???; 10 } + else 20 + ) + } + + def f6(x: Boolean) = { + println( + if (x) { throw new Error(""); 10 } + else 20 + ) + } + + def f7(x: Boolean) = { + println( + if (x) throw new Error("") + else 20 + ) + } + + def f8(x: Boolean) = { + println( + if (x) throw new Error("") + else 20 + ) + } +} + +object Test extends App { + new C() +} diff --git a/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala b/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala index 8518d5c832fb..fb677fc84b88 100644 --- a/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala +++ b/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala @@ -42,7 +42,7 @@ object CodeGenTools { compiler } - def compile(compiler: Global = newCompiler())(code: String): List[(String, Array[Byte])] = { + def compile(compiler: Global)(code: String): List[(String, Array[Byte])] = { compiler.reporter.reset() resetOutput(compiler) val run = new compiler.Run() @@ -51,11 +51,16 @@ object CodeGenTools { (for (f <- outDir.iterator if !f.isDirectory) yield (f.name, f.toByteArray)).toList } - def compileClasses(compiler: Global = newCompiler())(code: String): List[ClassNode] = { + def compileClasses(compiler: Global)(code: String): List[ClassNode] = { compile(compiler)(code).map(p => AsmUtils.readClass(p._2)).sortBy(_.name) } - def compileMethods(compiler: Global = newCompiler())(code: String): List[MethodNode] = { + def compileMethods(compiler: Global)(code: String): List[MethodNode] = { compileClasses(compiler)(s"class C { $code }").head.methods.asScala.toList.filterNot(_.name == "") } + + def singleMethodInstructions(compiler: Global)(code: String): List[Instruction] = { + val List(m) = compileMethods(compiler)(code) + instructionsFromMethod(m) + } } diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala index 4e62cc64e43d..ae08d10b7957 100644 --- a/test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala +++ b/test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala @@ -18,6 +18,14 @@ import ASMConverters._ class UnreachableCodeTest { import UnreachableCodeTest._ + // jvm-1.6 enables emitting stack map frames, which impacts the code generation wrt dead basic blocks, + // see comment in BCodeBodyBuilder + val dceCompiler = newCompiler(extraArgs = "-target:jvm-1.6 -Ybackend:GenBCode -Yopt:unreachable-code") + val noOptCompiler = newCompiler(extraArgs = "-target:jvm-1.6 -Ybackend:GenBCode -Yopt:l:none") + + // jvm-1.5 disables computing stack map frames, and it emits dead code as-is. + val noOptNoFramesCompiler = newCompiler(extraArgs = "-target:jvm-1.5 -Ybackend:GenBCode -Yopt:l:none") + @Test def basicElimination(): Unit = { assertEliminateDead( @@ -96,6 +104,36 @@ class UnreachableCodeTest { ) } + @Test + def basicEliminationCompiler(): Unit = { + val code = "def f: Int = { return 1; 2 }" + val withDce = singleMethodInstructions(dceCompiler)(code) + assertSameCode(withDce.dropNonOp, List(Op(ICONST_1), Op(IRETURN))) + + val noDce = singleMethodInstructions(noOptCompiler)(code) + + // The emitted code is ICONST_1, IRETURN, ICONST_2, IRETURN. The latter two are dead. + // + // GenBCode puts the last IRETURN into a new basic block: it emits a label before the second + // IRETURN. This is an implementation detail, it may change; it affects the outcome of this test. + // + // During classfile writing with COMPUTE_FAMES (-target:jvm-1.6 or larger), the ClassfileWriter + // puts the ICONST_2 into a new basic block, because the preceding operation (IRETURN) ends + // the current block. We get something like + // + // L1: ICONST_1; IRETURN + // L2: ICONST_2 << dead + // L3: IRETURN << dead + // + // Finally, instructions in the dead basic blocks are replaced by ATHROW, as explained in + // a comment in BCodeBodyBuilder. + assertSameCode(noDce.dropNonOp, List(Op(ICONST_1), Op(IRETURN), Op(ATHROW), Op(ATHROW))) + + // when NOT computing stack map frames, ASM's ClassWriter does not replace dead code by NOP/ATHROW + val noDceNoFrames = singleMethodInstructions(noOptNoFramesCompiler)(code) + assertSameCode(noDceNoFrames.dropNonOp, List(Op(ICONST_1), Op(IRETURN), Op(ICONST_2), Op(IRETURN))) + } + @Test def metaTest(): Unit = { assertEliminateDead() // no instructions @@ -153,10 +191,11 @@ object UnreachableCodeTest { val cls = wrapInClass(genMethod()(code.map(_._1): _*)) LocalOpt.removeUnreachableCode(cls) val nonEliminated = instructionsFromMethod(cls.methods.get(0)) - val expectedLive = code.filter(_._2).map(_._1).toList - - assertTrue(s"\nExpected: $expectedLive\nActual : $nonEliminated", nonEliminated === expectedLive) + assertSameCode(nonEliminated, expectedLive) } + def assertSameCode(actual: List[Instruction], expected: List[Instruction]): Unit = { + assertTrue(s"\nExpected: $expected\nActual : $actual", actual === expected) + } } From 01f5435318551ce12787b120440572f169c71463 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Fri, 29 Aug 2014 13:44:36 +0200 Subject: [PATCH 537/826] SI-8568 unreachable test now passes in GenBCode --- test/files/jvm/unreachable.flags | 1 - 1 file changed, 1 deletion(-) delete mode 100644 test/files/jvm/unreachable.flags diff --git a/test/files/jvm/unreachable.flags b/test/files/jvm/unreachable.flags deleted file mode 100644 index 49f2d2c4c833..000000000000 --- a/test/files/jvm/unreachable.flags +++ /dev/null @@ -1 +0,0 @@ --Ybackend:GenASM From 59070cc385560b48267cbc77e872027dd8304c05 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 4 Sep 2014 08:07:57 +0200 Subject: [PATCH 538/826] Remove stale local variables and exception handlers after DCE This is required for correctness of the generated bytecode. Exception handlers and local variable descriptors specify code offset ranges. These offsets have to exist, not be eliminated. --- .../nsc/backend/jvm/BCodeBodyBuilder.scala | 3 +- .../nsc/backend/jvm/BCodeSkelBuilder.scala | 7 ++ .../tools/nsc/backend/jvm/BackendStats.scala | 7 ++ .../tools/nsc/backend/jvm/GenBCode.scala | 13 +- .../tools/nsc/backend/jvm/opt/LocalOpt.scala | 116 +++++++++++++++++- .../scala/tools/partest/ASMConverters.scala | 54 +++++--- .../tools/nsc/backend/jvm/CodeGenTools.scala | 17 ++- .../nsc/backend/jvm/DirectCompileTest.scala | 2 +- .../jvm/opt/EmptyExceptionHandlersTest.scala | 92 ++++++++++++++ .../backend/jvm/opt/UnreachableCodeTest.scala | 24 +++- .../jvm/opt/UnusedLocalVariablesTest.scala | 87 +++++++++++++ 11 files changed, 386 insertions(+), 36 deletions(-) create mode 100644 test/junit/scala/tools/nsc/backend/jvm/opt/EmptyExceptionHandlersTest.scala create mode 100644 test/junit/scala/tools/nsc/backend/jvm/opt/UnusedLocalVariablesTest.scala diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index 68b6f1af37cd..ba97cf3748cb 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -282,9 +282,10 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { val Local(tk, _, idx, isSynth) = locals.getOrMakeLocal(sym) if (rhs == EmptyTree) { emitZeroOf(tk) } else { genLoad(rhs, tk) } + val localVarStart = currProgramPoint() bc.store(idx, tk) if (!isSynth) { // there are case ValDef's emitted by patmat - varsInScope ::= (sym -> currProgramPoint()) + varsInScope ::= (sym -> localVarStart) } generatedType = UNIT diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala index 4592031a31a6..03bc32061b99 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala @@ -346,6 +346,13 @@ abstract class BCodeSkelBuilder extends BCodeHelpers { /* * Bookkeeping for method-local vars and method-params. + * + * TODO: use fewer slots. local variable slots are never re-used in separate blocks. + * In the following example, x and y could use the same slot. + * def foo() = { + * { val x = 1 } + * { val y = "a" } + * } */ object locals { diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BackendStats.scala b/src/compiler/scala/tools/nsc/backend/jvm/BackendStats.scala index 921aef7aca11..d96ee933b7bb 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BackendStats.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BackendStats.scala @@ -16,4 +16,11 @@ object BackendStats { val bcodeGenStat = newSubTimer("code generation", bcodeTimer) val bcodeDceTimer = newSubTimer("dead code elimination", bcodeTimer) val bcodeWriteTimer = newSubTimer("classfile writing", bcodeTimer) + + def timed[T](timer: Statistics.Timer)(body: => T) = { + val start = Statistics.startTimer(timer) + val res = body + Statistics.stopTimer(timer, start) + res + } } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala index a788cea532d9..ba94a9c44c64 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala @@ -14,6 +14,7 @@ import scala.annotation.switch import scala.reflect.internal.util.Statistics import scala.tools.asm +import scala.tools.asm.tree.ClassNode /* * Prepare in-memory representations of classfiles using the ASM Tree API, and serialize them to disk. @@ -214,6 +215,14 @@ abstract class GenBCode extends BCodeSyncAndTry { * - converting the plain ClassNode to byte array and placing it on queue-3 */ class Worker2 { + def localOptimizations(classNode: ClassNode): Unit = { + def dce(): Boolean = BackendStats.timed(BackendStats.bcodeDceTimer) { + if (settings.YoptUnreachableCode) opt.LocalOpt.removeUnreachableCode(classNode) + else false + } + + dce() + } def run() { while (true) { @@ -224,9 +233,7 @@ abstract class GenBCode extends BCodeSyncAndTry { } else { try { - val dceStart = Statistics.startTimer(BackendStats.bcodeDceTimer) - if (settings.YoptUnreachableCode) opt.LocalOpt.removeUnreachableCode(item.plain) - Statistics.stopTimer(BackendStats.bcodeDceTimer, dceStart) + localOptimizations(item.plain) addToQ3(item) } catch { case ex: Throwable => diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala index b3a515c2ae5f..3acd2d61545a 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala @@ -7,10 +7,11 @@ package scala.tools.nsc package backend.jvm package opt -import scala.tools.asm.{MethodWriter, ClassWriter} +import scala.tools.asm.{Opcodes, MethodWriter, ClassWriter} import scala.tools.asm.tree.analysis.{Analyzer, BasicValue, BasicInterpreter} -import scala.tools.asm.tree.{LabelNode, ClassNode, MethodNode} +import scala.tools.asm.tree._ import scala.collection.convert.decorateAsScala._ +import scala.collection.{ mutable => m } /** * Intra-Method optimizations. @@ -24,7 +25,7 @@ object LocalOpt { */ def removeUnreachableCode(clazz: ClassNode): Boolean = { clazz.methods.asScala.foldLeft(false) { - case (changed, method) => removeUnreachableCode(method, clazz) || changed + case (changed, method) => removeUnreachableCode(method, clazz.name) || changed } } @@ -34,15 +35,44 @@ object LocalOpt { * Guide (http://asm.ow2.org/index.html), Section 8.2.1. It runs a data flow analysis, which only * computes Frame information for reachable instructions. Instructions for which no Frame data is * available after the analyis are unreachable. + * + * TODO doc: it also removes empty handlers, unused local vars + * + * Returns `true` if dead code in `method` has been eliminated. */ - private def removeUnreachableCode(method: MethodNode, ownerClass: ClassNode): Boolean = { + private def removeUnreachableCode(method: MethodNode, ownerClassName: String): Boolean = { + if (method.instructions.size == 0) return false // fast path for abstract methods + + val codeRemoved = removeUnreachableCodeImpl(method, ownerClassName) + + // unreachable-code also removes unused local variable nodes and empty exception handlers. + // This is required for correctness: such nodes are not allowed to refer to instruction offsets + // that don't exist (because they have been eliminated). + val localsRemoved = removeUnusedLocalVariableNodes(method) + val handlersRemoved = removeEmptyExceptionHandlers(method) + + // When eliminating a handler, the catch block becomes unreachable. The recursive invocation + // removes these blocks. + // Note that invoking removeUnreachableCode*Impl* a second time is not enough: removing the dead + // catch block can render other handlers empty, which also have to be removed in turn. + if (handlersRemoved) removeUnreachableCode(method, ownerClassName) + + // assert that we can leave local variable annotations as-is + def nullOrEmpty[T](l: java.util.List[T]) = l == null || l.isEmpty + assert(nullOrEmpty(method.visibleLocalVariableAnnotations), method.visibleLocalVariableAnnotations) + assert(nullOrEmpty(method.invisibleLocalVariableAnnotations), method.invisibleLocalVariableAnnotations) + + codeRemoved || localsRemoved || handlersRemoved + } + + private def removeUnreachableCodeImpl(method: MethodNode, ownerClassName: String): Boolean = { val initialSize = method.instructions.size if (initialSize == 0) return false // The data flow analysis requires the maxLocals / maxStack fields of the method to be computed. computeMaxLocalsMaxStack(method) val a = new Analyzer[BasicValue](new BasicInterpreter) - a.analyze(ownerClass.name, method) + a.analyze(ownerClassName, method) val frames = a.getFrames var i = 0 @@ -58,9 +88,83 @@ object LocalOpt { i += 1 } - method.instructions.size == initialSize + method.instructions.size != initialSize + } + + /** + * Remove exception handlers that cover empty code blocks from all methods of `clazz`. + * Returns `true` if any exception handler was eliminated. + */ + def removeEmptyExceptionHandlers(clazz: ClassNode): Boolean = { + clazz.methods.asScala.foldLeft(false) { + case (changed, method) => removeEmptyExceptionHandlers(method) || changed + } + } + + /** + * Remove exception handlers that cover empty code blocks. A block is considered empty if it + * consist only of labels, frames, line numbers, nops and gotos. + * + * Note that no instructions are eliminated. + * + * @return `true` if some exception handler was eliminated. + */ + def removeEmptyExceptionHandlers(method: MethodNode): Boolean = { + /** True if there exists code between start and end. */ + def containsExecutableCode(start: AbstractInsnNode, end: LabelNode): Boolean = { + start != end && (start.getOpcode match { + // FrameNode, LabelNode and LineNumberNode have opcode == -1. + case -1 | Opcodes.NOP | Opcodes.GOTO => containsExecutableCode(start.getNext, end) + case _ => true + }) + } + + val initialNumberHandlers = method.tryCatchBlocks.size + val handlersIter = method.tryCatchBlocks.iterator() + while(handlersIter.hasNext) { + val handler = handlersIter.next() + if (!containsExecutableCode(handler.start, handler.end)) handlersIter.remove() + } + method.tryCatchBlocks.size != initialNumberHandlers } + /** + * Remove all non-parameter entries from the local variable table which denote variables that are + * not actually read or written. + * + * Note that each entry in the local variable table has a start, end and index. Two entries with + * the same index, but distinct start / end ranges are different variables, they may have not the + * same type or name. + * + * TODO: also re-allocate locals to occupy fewer slots after eliminating unused ones + */ + def removeUnusedLocalVariableNodes(method: MethodNode): Boolean = { + def variableIsUsed(start: AbstractInsnNode, end: LabelNode, varIndex: Int): Boolean = { + start != end && (start match { + case v: VarInsnNode => v.`var` == varIndex + case _ => variableIsUsed(start.getNext, end, varIndex) + }) + } + + val initialNumVars = method.localVariables.size + val localsIter = method.localVariables.iterator() + // The parameters and `this` (for instance methods) have the lowest indices in the local variables + // table. Note that double / long fields occupy two slots, so we sum up the sizes. Since getSize + // returns 0 for void, we have to add `max 1`. + val paramsSize = scala.tools.asm.Type.getArgumentTypes(method.desc).map(_.getSize max 1).sum + val thisSize = if ((method.access & Opcodes.ACC_STATIC) == 0) 1 else 0 + val endParamIndex = paramsSize + thisSize + while (localsIter.hasNext) { + val local = localsIter.next() + // parameters and `this` have the lowest indices, starting at 0 + val used = local.index < endParamIndex || variableIsUsed(local.start, local.end, local.index) + if (!used) + localsIter.remove() + } + method.localVariables.size == initialNumVars + } + + /** * In order to run an Analyzer, the maxLocals / maxStack fields need to be available. The ASM * framework only computes these values during bytecode generation. diff --git a/src/partest-extras/scala/tools/partest/ASMConverters.scala b/src/partest-extras/scala/tools/partest/ASMConverters.scala index f4a90d9acf99..d443a3111224 100644 --- a/src/partest-extras/scala/tools/partest/ASMConverters.scala +++ b/src/partest-extras/scala/tools/partest/ASMConverters.scala @@ -3,7 +3,6 @@ package scala.tools.partest import scala.collection.JavaConverters._ import scala.tools.asm import asm.{tree => t} -import scala.tools.asm.tree.LabelNode /** Makes using ASM from ByteCodeTests more convenient. * @@ -15,13 +14,9 @@ object ASMConverters { /** * Transform the instructions of an ASM Method into a list of [[Instruction]]s. */ - def instructionsFromMethod(meth: t.MethodNode): List[Instruction] = { - val insns = meth.instructions - val asmToScala = new AsmToScala { - def labelIndex(l: t.LabelNode) = insns.indexOf(l) - } - asmToScala.convert(insns.iterator.asScala.toList) - } + def instructionsFromMethod(meth: t.MethodNode): List[Instruction] = new AsmToScala(meth).instructions + + def convertMethod(meth: t.MethodNode): Method = new AsmToScala(meth).method implicit class RichInstructionLists(val self: List[Instruction]) extends AnyVal { def === (other: List[Instruction]) = equivalentBytecode(self, other) @@ -61,6 +56,8 @@ object ASMConverters { } } + case class Method(instructions: List[Instruction], handlers: List[ExceptionHandler], localVars: List[LocalVariable]) + case class Field (opcode: Int, owner: String, name: String, desc: String) extends Instruction case class Incr (opcode: Int, `var`: Int, incr: Int) extends Instruction case class Op (opcode: Int) extends Instruction @@ -69,7 +66,7 @@ object ASMConverters { case class Ldc (opcode: Int, cst: Any) extends Instruction case class LookupSwitch(opcode: Int, dflt: Label, keys: List[Int], labels: List[Label]) extends Instruction case class TableSwitch (opcode: Int, min: Int, max: Int, dflt: Label, labels: List[Label]) extends Instruction - case class Method (opcode: Int, owner: String, name: String, desc: String, itf: Boolean) extends Instruction + case class Invoke (opcode: Int, owner: String, name: String, desc: String, itf: Boolean) extends Instruction case class NewArray (opcode: Int, desc: String, dims: Int) extends Instruction case class TypeOp (opcode: Int, desc: String) extends Instruction case class VarOp (opcode: Int, `var`: Int) extends Instruction @@ -77,13 +74,18 @@ object ASMConverters { case class FrameEntry (`type`: Int, local: List[Any], stack: List[Any]) extends Instruction { def opcode: Int = -1 } case class LineNumber (line: Int, start: Label) extends Instruction { def opcode: Int = -1 } - abstract class AsmToScala { + case class ExceptionHandler(start: Label, end: Label, handler: Label, desc: Option[String]) + case class LocalVariable(name: String, desc: String, signature: Option[String], start: Label, end: Label, index: Int) - def labelIndex(l: t.LabelNode): Int + class AsmToScala(asmMethod: t.MethodNode) { - def op(i: t.AbstractInsnNode): Int = i.getOpcode + def instructions: List[Instruction] = asmMethod.instructions.iterator.asScala.toList map apply - def convert(instructions: List[t.AbstractInsnNode]): List[Instruction] = instructions map apply + def method: Method = Method(instructions, convertHandlers(asmMethod), convertLocalVars(asmMethod)) + + private def labelIndex(l: t.LabelNode): Int = asmMethod.instructions.indexOf(l) + + private def op(i: t.AbstractInsnNode): Int = i.getOpcode private def lst[T](xs: java.util.List[T]): List[T] = if (xs == null) Nil else xs.asScala.toList @@ -108,7 +110,7 @@ object ASMConverters { case i: t.LdcInsnNode => Ldc (op(i), i.cst: Any) case i: t.LookupSwitchInsnNode => LookupSwitch (op(i), applyLabel(i.dflt), lst(i.keys) map (x => x: Int), lst(i.labels) map applyLabel) case i: t.TableSwitchInsnNode => TableSwitch (op(i), i.min, i.max, applyLabel(i.dflt), lst(i.labels) map applyLabel) - case i: t.MethodInsnNode => Method (op(i), i.owner, i.name, i.desc, i.itf) + case i: t.MethodInsnNode => Invoke (op(i), i.owner, i.name, i.desc, i.itf) case i: t.MultiANewArrayInsnNode => NewArray (op(i), i.desc, i.dims) case i: t.TypeInsnNode => TypeOp (op(i), i.desc) case i: t.VarInsnNode => VarOp (op(i), i.`var`) @@ -116,6 +118,14 @@ object ASMConverters { case i: t.FrameNode => FrameEntry (i.`type`, mapOverFrameTypes(lst(i.local)), mapOverFrameTypes(lst(i.stack))) case i: t.LineNumberNode => LineNumber (i.line, applyLabel(i.start)) } + + private def convertHandlers(method: t.MethodNode): List[ExceptionHandler] = { + method.tryCatchBlocks.asScala.map(h => ExceptionHandler(applyLabel(h.start), applyLabel(h.end), applyLabel(h.handler), Option(h.`type`)))(collection.breakOut) + } + + private def convertLocalVars(method: t.MethodNode): List[LocalVariable] = { + method.localVariables.asScala.map(v => LocalVariable(v.name, v.desc, Option(v.signature), applyLabel(v.start), applyLabel(v.end), v.index))(collection.breakOut) + } } import collection.mutable.{Map => MMap} @@ -159,15 +169,21 @@ object ASMConverters { }) && equivalentBytecode(as.tail, bs.tail, varMap, labelMap) } - /** - * Convert back a list of [[Instruction]]s to ASM land. The code is emitted into the parameter - * `method`. - */ def applyToMethod(method: t.MethodNode, instructions: List[Instruction]): Unit = { val asmLabel = createLabelNodes(instructions) instructions.foreach(visitMethod(method, _, asmLabel)) } + /** + * Convert back a [[Method]] to ASM land. The code is emitted into the parameter `asmMethod`. + */ + def applyToMethod(asmMethod: t.MethodNode, method: Method): Unit = { + val asmLabel = createLabelNodes(method.instructions) + method.instructions.foreach(visitMethod(asmMethod, _, asmLabel)) + method.handlers.foreach(h => asmMethod.visitTryCatchBlock(asmLabel(h.start), asmLabel(h.end), asmLabel(h.handler), h.desc.orNull)) + method.localVars.foreach(v => asmMethod.visitLocalVariable(v.name, v.desc, v.signature.orNull, asmLabel(v.start), asmLabel(v.end), v.index)) + } + private def createLabelNodes(instructions: List[Instruction]): Map[Label, asm.Label] = { val labels = instructions collect { case l: Label => l @@ -190,7 +206,7 @@ object ASMConverters { case Ldc(op, cst) => method.visitLdcInsn(cst) case LookupSwitch(op, dflt, keys, labels) => method.visitLookupSwitchInsn(asmLabel(dflt), keys.toArray, (labels map asmLabel).toArray) case TableSwitch(op, min, max, dflt, labels) => method.visitTableSwitchInsn(min, max, asmLabel(dflt), (labels map asmLabel).toArray: _*) - case Method(op, owner, name, desc, itf) => method.visitMethodInsn(op, owner, name, desc, itf) + case Invoke(op, owner, name, desc, itf) => method.visitMethodInsn(op, owner, name, desc, itf) case NewArray(op, desc, dims) => method.visitMultiANewArrayInsn(desc, dims) case TypeOp(op, desc) => method.visitTypeInsn(op, desc) case VarOp(op, vr) => method.visitVarInsn(op, vr) diff --git a/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala b/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala index fb677fc84b88..15bc1f427d18 100644 --- a/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala +++ b/test/junit/scala/tools/nsc/backend/jvm/CodeGenTools.scala @@ -1,5 +1,7 @@ package scala.tools.nsc.backend.jvm +import org.junit.Assert._ + import scala.reflect.internal.util.BatchSourceFile import scala.reflect.io.VirtualDirectory import scala.tools.asm.Opcodes @@ -16,9 +18,11 @@ object CodeGenTools { name: String = "m", descriptor: String = "()V", genericSignature: String = null, - throwsExceptions: Array[String] = null)(body: Instruction*): MethodNode = { + throwsExceptions: Array[String] = null, + handlers: List[ExceptionHandler] = Nil, + localVars: List[LocalVariable] = Nil)(body: Instruction*): MethodNode = { val node = new MethodNode(flags, name, descriptor, genericSignature, throwsExceptions) - applyToMethod(node, body.toList) + applyToMethod(node, Method(body.toList, handlers, localVars)) node } @@ -63,4 +67,13 @@ object CodeGenTools { val List(m) = compileMethods(compiler)(code) instructionsFromMethod(m) } + + def singleMethod(compiler: Global)(code: String): Method = { + val List(m) = compileMethods(compiler)(code) + convertMethod(m) + } + + def assertSameCode(actual: List[Instruction], expected: List[Instruction]): Unit = { + assertTrue(s"\nExpected: $expected\nActual : $actual", actual === expected) + } } diff --git a/test/junit/scala/tools/nsc/backend/jvm/DirectCompileTest.scala b/test/junit/scala/tools/nsc/backend/jvm/DirectCompileTest.scala index 640f22fc4792..2fb5bb8052b9 100644 --- a/test/junit/scala/tools/nsc/backend/jvm/DirectCompileTest.scala +++ b/test/junit/scala/tools/nsc/backend/jvm/DirectCompileTest.scala @@ -58,7 +58,7 @@ class DirectCompileTest { List(IntOp(BIPUSH, 10), Op(IRETURN))) assertTrue(instructionsFromMethod(g).dropNonOp === - List(VarOp(ALOAD, 0), Method(INVOKEVIRTUAL, "C", "f", "()I", false), Op(IRETURN))) + List(VarOp(ALOAD, 0), Invoke(INVOKEVIRTUAL, "C", "f", "()I", false), Op(IRETURN))) } @Test diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/EmptyExceptionHandlersTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/EmptyExceptionHandlersTest.scala new file mode 100644 index 000000000000..57fa1a7b66a8 --- /dev/null +++ b/test/junit/scala/tools/nsc/backend/jvm/opt/EmptyExceptionHandlersTest.scala @@ -0,0 +1,92 @@ +package scala.tools.nsc +package backend.jvm +package opt + +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 +import org.junit.Test +import scala.tools.asm.Opcodes._ +import org.junit.Assert._ + +import CodeGenTools._ +import scala.tools.partest.ASMConverters +import ASMConverters._ + +@RunWith(classOf[JUnit4]) +class EmptyExceptionHandlersTest { + + val exceptionDescriptor = "java/lang/Exception" + + @Test + def eliminateEmpty(): Unit = { + val handlers = List(ExceptionHandler(Label(1), Label(2), Label(2), Some(exceptionDescriptor))) + val asmMethod = genMethod(handlers = handlers)( + Label(1), + Label(2), + Op(RETURN) + ) + assertTrue(convertMethod(asmMethod).handlers.length == 1) + LocalOpt.removeEmptyExceptionHandlers(asmMethod) + assertTrue(convertMethod(asmMethod).handlers.isEmpty) + } + + @Test + def eliminateHandlersGuardingNops(): Unit = { + val handlers = List(ExceptionHandler(Label(1), Label(2), Label(2), Some(exceptionDescriptor))) + val asmMethod = genMethod(handlers = handlers)( + Label(1), // nops only + Op(NOP), + Op(NOP), + Jump(GOTO, Label(3)), + Op(NOP), + Label(3), + Op(NOP), + Jump(GOTO, Label(4)), + + Label(2), // handler + Op(ACONST_NULL), + Op(ATHROW), + + Label(4), // return + Op(RETURN) + ) + assertTrue(convertMethod(asmMethod).handlers.length == 1) + LocalOpt.removeEmptyExceptionHandlers(asmMethod) + assertTrue(convertMethod(asmMethod).handlers.isEmpty) + } + + val noOptCompiler = newCompiler(extraArgs = "-Ybackend:GenBCode -Yopt:l:none") + val dceCompiler = newCompiler(extraArgs = "-Ybackend:GenBCode -Yopt:unreachable-code") + + @Test + def eliminateUnreachableHandler(): Unit = { + val code = "def f: Unit = try { } catch { case _: Exception => println(0) }; println(1)" + + assertTrue(singleMethod(noOptCompiler)(code).handlers.length == 1) + val optMethod = singleMethod(dceCompiler)(code) + assertTrue(optMethod.handlers.isEmpty) + + val code2 = + """def f: Unit = { + | println(0) + | return + | try { throw new Exception("") } // removed by dce, so handler will be removed as well + | catch { case _: Exception => println(1) } + | println(2) + |}""".stripMargin + + assertTrue(singleMethod(dceCompiler)(code2).handlers.isEmpty) + } + + @Test + def keepAliveHandlers(): Unit = { + val code = + """def f: Int = { + | println(0) + | try { 1 } + | catch { case _: Exception => 2 } + |}""".stripMargin + + assertTrue(singleMethod(dceCompiler)(code).handlers.length == 1) + } +} diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala index ae08d10b7957..a3bd7ae6fe65 100644 --- a/test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala +++ b/test/junit/scala/tools/nsc/backend/jvm/opt/UnreachableCodeTest.scala @@ -135,6 +135,26 @@ class UnreachableCodeTest { } @Test + def eliminateDeadCatchBlocks(): Unit = { + val code = "def f: Int = { return 0; try { 1 } catch { case _: Exception => 2 } }" + assertSameCode(singleMethodInstructions(dceCompiler)(code).dropNonOp, + List(Op(ICONST_0), Op(IRETURN))) + + val code2 = "def f: Unit = { try { } catch { case _: Exception => () }; () }" + // DCE only removes dead basic blocks, but not NOPs, and also not useless jumps + assertSameCode(singleMethodInstructions(dceCompiler)(code2).dropNonOp, + List(Op(NOP), Jump(GOTO, Label(33)), Label(33), Op(RETURN))) + + val code3 = "def f: Unit = { try { } catch { case _: Exception => try { } catch { case _: Exception => () } }; () }" + assertSameCode(singleMethodInstructions(dceCompiler)(code3).dropNonOp, + List(Op(NOP), Jump(GOTO, Label(33)), Label(33), Op(RETURN))) + + val code4 = "def f: Unit = { try { try { } catch { case _: Exception => () } } catch { case _: Exception => () }; () }" + assertSameCode(singleMethodInstructions(dceCompiler)(code4).dropNonOp, + List(Op(NOP), Jump(GOTO, Label(4)), Label(4), Jump(GOTO, Label(7)), Label(7), Op(RETURN))) + } + + @Test // test the dce-testing tools def metaTest(): Unit = { assertEliminateDead() // no instructions @@ -194,8 +214,4 @@ object UnreachableCodeTest { val expectedLive = code.filter(_._2).map(_._1).toList assertSameCode(nonEliminated, expectedLive) } - - def assertSameCode(actual: List[Instruction], expected: List[Instruction]): Unit = { - assertTrue(s"\nExpected: $expected\nActual : $actual", actual === expected) - } } diff --git a/test/junit/scala/tools/nsc/backend/jvm/opt/UnusedLocalVariablesTest.scala b/test/junit/scala/tools/nsc/backend/jvm/opt/UnusedLocalVariablesTest.scala new file mode 100644 index 000000000000..24a1f9d1c1fb --- /dev/null +++ b/test/junit/scala/tools/nsc/backend/jvm/opt/UnusedLocalVariablesTest.scala @@ -0,0 +1,87 @@ +package scala.tools.nsc +package backend.jvm +package opt + +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 +import org.junit.Test +import scala.tools.asm.Opcodes._ +import org.junit.Assert._ +import scala.collection.JavaConverters._ + +import CodeGenTools._ +import scala.tools.partest.ASMConverters +import ASMConverters._ + +@RunWith(classOf[JUnit4]) +class UnusedLocalVariablesTest { + val dceCompiler = newCompiler(extraArgs = "-Ybackend:GenBCode -Yopt:unreachable-code") + + @Test + def removeUnusedVar(): Unit = { + val code = """def f(a: Long, b: String, c: Double): Unit = { return; var x = a; var y = x + 10 }""" + assertLocalVarCount(code, 4) // `this, a, b, c` + + val code2 = """def f(): Unit = { var x = if (true) return else () }""" + assertLocalVarCount(code2, 1) // x is eliminated, constant folding in scalac removes the if + + val code3 = """def f: Unit = return""" // paramless method + assertLocalVarCount(code3, 1) // this + } + + @Test + def keepUsedVar(): Unit = { + val code = """def f(a: Long, b: String, c: Double): Unit = { val x = 10 + a; val y = x + 10 }""" + assertLocalVarCount(code, 6) + + val code2 = """def f(a: Long): Unit = { var x = if (a == 0l) return else () }""" + assertLocalVarCount(code2, 3) // remains + } + + @Test + def constructorLocals(): Unit = { + val code = """class C { + | def this(a: Int) = { + | this() + | throw new Exception("") + | val y = 0 + | } + |} + |""".stripMargin + val cls = compileClasses(dceCompiler)(code).head + val m = convertMethod(cls.methods.asScala.toList.find(_.desc == "(I)V").get) + assertTrue(m.localVars.length == 2) // this, a, but not y + + + val code2 = + """class C { + | { + | throw new Exception("") + | val a = 0 + | } + |} + | + |object C { + | { + | throw new Exception("") + | val b = 1 + | } + |} + """.stripMargin + + val clss2 = compileClasses(dceCompiler)(code2) + val cls2 = clss2.find(_.name == "C").get + val companion2 = clss2.find(_.name == "C$").get + + val clsConstr = convertMethod(cls2.methods.asScala.toList.find(_.name == "").get) + val companionConstr = convertMethod(companion2.methods.asScala.toList.find(_.name == "").get) + + assertTrue(clsConstr.localVars.length == 1) // this + assertTrue(companionConstr.localVars.length == 1) // this + } + + def assertLocalVarCount(code: String, numVars: Int): Unit = { + assertTrue(singleMethod(dceCompiler)(code).localVars.length == numVars) + } + +} From 24ccfa05bb9af066fe91f182c5f95de837139f0b Mon Sep 17 00:00:00 2001 From: Konstantin Fedorov Date: Mon, 8 Sep 2014 09:51:41 +0400 Subject: [PATCH 539/826] SI-8398 - unused warning reports lazy val as a method Compiler internals treat lazy vals as methods. Therefore, we need to have a special case for them when assembling the warning message. --- .../nsc/typechecker/TypeDiagnostics.scala | 2 +- test/files/neg/warn-unused-privates.check | 39 ++++++++++--------- test/files/neg/warn-unused-privates.scala | 1 + 3 files changed, 23 insertions(+), 19 deletions(-) diff --git a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala index 8d29d28908e2..1dac27639c50 100644 --- a/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala +++ b/src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala @@ -532,7 +532,7 @@ trait TypeDiagnostics { if (sym.isDefaultGetter) "default argument" else if (sym.isConstructor) "constructor" else if (sym.isVar || sym.isGetter && sym.accessed.isVar) "var" - else if (sym.isVal || sym.isGetter && sym.accessed.isVal) "val" + else if (sym.isVal || sym.isGetter && sym.accessed.isVal || sym.isLazy) "val" else if (sym.isSetter) "setter" else if (sym.isMethod) "method" else if (sym.isModule) "object" diff --git a/test/files/neg/warn-unused-privates.check b/test/files/neg/warn-unused-privates.check index d012869c934a..4876ed8fc24a 100644 --- a/test/files/neg/warn-unused-privates.check +++ b/test/files/neg/warn-unused-privates.check @@ -10,57 +10,60 @@ warn-unused-privates.scala:6: warning: private val in class Bippy is never used warn-unused-privates.scala:13: warning: private val in object Bippy is never used private val HEY_INSTANCE: Int = 1000 // warn ^ -warn-unused-privates.scala:35: warning: private val in class Boppy is never used +warn-unused-privates.scala:14: warning: private val in object Bippy is never used + private lazy val BOOL: Boolean = true // warn + ^ +warn-unused-privates.scala:36: warning: private val in class Boppy is never used private val hummer = "def" // warn ^ -warn-unused-privates.scala:42: warning: private var in trait Accessors is never used +warn-unused-privates.scala:43: warning: private var in trait Accessors is never used private var v1: Int = 0 // warn ^ -warn-unused-privates.scala:42: warning: private setter in trait Accessors is never used +warn-unused-privates.scala:43: warning: private setter in trait Accessors is never used private var v1: Int = 0 // warn ^ -warn-unused-privates.scala:43: warning: private setter in trait Accessors is never used +warn-unused-privates.scala:44: warning: private setter in trait Accessors is never used private var v2: Int = 0 // warn, never set ^ -warn-unused-privates.scala:44: warning: private var in trait Accessors is never used +warn-unused-privates.scala:45: warning: private var in trait Accessors is never used private var v3: Int = 0 // warn, never got ^ -warn-unused-privates.scala:56: warning: private default argument in trait DefaultArgs is never used +warn-unused-privates.scala:57: warning: private default argument in trait DefaultArgs is never used private def bippy(x1: Int, x2: Int = 10, x3: Int = 15): Int = x1 + x2 + x3 ^ -warn-unused-privates.scala:56: warning: private default argument in trait DefaultArgs is never used +warn-unused-privates.scala:57: warning: private default argument in trait DefaultArgs is never used private def bippy(x1: Int, x2: Int = 10, x3: Int = 15): Int = x1 + x2 + x3 ^ -warn-unused-privates.scala:67: warning: local var in method f0 is never used +warn-unused-privates.scala:68: warning: local var in method f0 is never used var x = 1 // warn ^ -warn-unused-privates.scala:74: warning: local val in method f1 is never used +warn-unused-privates.scala:75: warning: local val in method f1 is never used val b = new Outer // warn ^ -warn-unused-privates.scala:84: warning: private object in object Types is never used +warn-unused-privates.scala:85: warning: private object in object Types is never used private object Dongo { def f = this } // warn ^ -warn-unused-privates.scala:94: warning: local object in method l1 is never used +warn-unused-privates.scala:95: warning: local object in method l1 is never used object HiObject { def f = this } // warn ^ -warn-unused-privates.scala:78: warning: local var x in method f2 is never set - it could be a val +warn-unused-privates.scala:79: warning: local var x in method f2 is never set - it could be a val var x = 100 // warn about it being a var ^ -warn-unused-privates.scala:85: warning: private class Bar1 in object Types is never used +warn-unused-privates.scala:86: warning: private class Bar1 in object Types is never used private class Bar1 // warn ^ -warn-unused-privates.scala:87: warning: private type Alias1 in object Types is never used +warn-unused-privates.scala:88: warning: private type Alias1 in object Types is never used private type Alias1 = String // warn ^ -warn-unused-privates.scala:95: warning: local class Hi is never used +warn-unused-privates.scala:96: warning: local class Hi is never used class Hi { // warn ^ -warn-unused-privates.scala:99: warning: local class DingDongDoobie is never used +warn-unused-privates.scala:100: warning: local class DingDongDoobie is never used class DingDongDoobie // warn ^ -warn-unused-privates.scala:102: warning: local type OtherThing is never used +warn-unused-privates.scala:103: warning: local type OtherThing is never used type OtherThing = String // warn ^ error: No warnings can be incurred under -Xfatal-warnings. -21 warnings found +22 warnings found one error found diff --git a/test/files/neg/warn-unused-privates.scala b/test/files/neg/warn-unused-privates.scala index cb6e946a3407..2faa07e75940 100644 --- a/test/files/neg/warn-unused-privates.scala +++ b/test/files/neg/warn-unused-privates.scala @@ -11,6 +11,7 @@ object Bippy { def hi(x: Bippy) = x.HI_COMPANION private val HI_INSTANCE: Int = 500 // no warn, accessed from instance private val HEY_INSTANCE: Int = 1000 // warn + private lazy val BOOL: Boolean = true // warn } class A(val msg: String) From 9132efa4a8511e267c808c95df4d2e3de68277e6 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Thu, 11 Sep 2014 10:22:37 +0200 Subject: [PATCH 540/826] Address review feedback. --- .../scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala | 4 ++-- src/compiler/scala/tools/nsc/backend/jvm/BackendStats.scala | 6 ++---- src/partest-extras/scala/tools/partest/ASMConverters.scala | 4 ++-- src/partest-extras/scala/tools/partest/BytecodeTest.scala | 2 +- test/files/run/nothingTypeDce.scala | 4 +++- 5 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala index ba97cf3748cb..daf36ce37494 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala @@ -824,7 +824,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { * the stack. "Phantom" because it never exists: such methods always throw, but the JVM does * not know that. * - * Note: The two verifiers (old: type inference, new: type checking) have differnet + * Note: The two verifiers (old: type inference, new: type checking) have different * requirements. Very briefly: * * Old (http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.10.2.1): at @@ -832,7 +832,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder { * - Stack is same size and has same typed values * - Local and stack values need to have consistent types * - In practice, the old verifier seems to ignore unreachable code and accept any - * instrucitons after an ATHROW. For example, there can be another ATHROW (without + * instructions after an ATHROW. For example, there can be another ATHROW (without * loading another throwable first). * * New (http://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.10.1) diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BackendStats.scala b/src/compiler/scala/tools/nsc/backend/jvm/BackendStats.scala index d96ee933b7bb..4b9383c67c21 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BackendStats.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BackendStats.scala @@ -17,10 +17,8 @@ object BackendStats { val bcodeDceTimer = newSubTimer("dead code elimination", bcodeTimer) val bcodeWriteTimer = newSubTimer("classfile writing", bcodeTimer) - def timed[T](timer: Statistics.Timer)(body: => T) = { + def timed[T](timer: Statistics.Timer)(body: => T): T = { val start = Statistics.startTimer(timer) - val res = body - Statistics.stopTimer(timer, start) - res + try body finally Statistics.stopTimer(timer, start) } } diff --git a/src/partest-extras/scala/tools/partest/ASMConverters.scala b/src/partest-extras/scala/tools/partest/ASMConverters.scala index d443a3111224..67a4e8ae01b6 100644 --- a/src/partest-extras/scala/tools/partest/ASMConverters.scala +++ b/src/partest-extras/scala/tools/partest/ASMConverters.scala @@ -141,9 +141,9 @@ object ASMConverters { } def sameVar(v1: Int, v2: Int) = same(v1, v2, varMap) def sameLabel(l1: Label, l2: Label) = same(l1.offset, l2.offset, labelMap) - def sameLabels(ls1: List[Label], ls2: List[Label]) = ls1.length == ls2.length && (ls1, ls2).zipped.forall(sameLabel) + def sameLabels(ls1: List[Label], ls2: List[Label]) = (ls1 corresponds ls2)(sameLabel) - def sameFrameTypes(ts1: List[Any], ts2: List[Any]) = ts1.length == ts2.length && (ts1, ts2).zipped.forall { + def sameFrameTypes(ts1: List[Any], ts2: List[Any]) = (ts1 corresponds ts2) { case (t1: Label, t2: Label) => sameLabel(t1, t2) case (x, y) => x == y } diff --git a/src/partest-extras/scala/tools/partest/BytecodeTest.scala b/src/partest-extras/scala/tools/partest/BytecodeTest.scala index c6fa279c5041..3261cada3716 100644 --- a/src/partest-extras/scala/tools/partest/BytecodeTest.scala +++ b/src/partest-extras/scala/tools/partest/BytecodeTest.scala @@ -84,7 +84,7 @@ abstract class BytecodeTest { /** * Compare the bytecodes of two methods. * - * The for the `similar` function, you probably want to pass [[ASMConverters.equivalentBytecode]]. + * For the `similar` function, you probably want to pass [[ASMConverters.equivalentBytecode]]. */ def similarBytecode(methA: MethodNode, methB: MethodNode, similar: (List[Instruction], List[Instruction]) => Boolean) = { val isa = instructionsFromMethod(methA) diff --git a/test/files/run/nothingTypeDce.scala b/test/files/run/nothingTypeDce.scala index 4b9d934eacf0..5f3692fd3366 100644 --- a/test/files/run/nothingTypeDce.scala +++ b/test/files/run/nothingTypeDce.scala @@ -26,7 +26,7 @@ class C { } def f5(x: Boolean) = { - // stack heights need to be the smae. ??? looks to the jvm like returning a value of + // stack heights need to be the same. ??? looks to the jvm like returning a value of // type Nothing$, need to drop or throw it. println( if (x) { ???; 10 } @@ -57,5 +57,7 @@ class C { } object Test extends App { + // creating an instance is enough to trigger bytecode verification for all methods, + // no need to invoke the methods. new C() } From 9ba986e61151cb370ba519f568042776c9f303df Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Thu, 11 Sep 2014 11:27:49 +0200 Subject: [PATCH 541/826] moves the impl of quasiquotes to scala.reflect This brings consistency with scala.reflect.reify and scala.reflect.macros already existing in scala-compiler. To the contrast, scala.tools.reflect, the previous home of quasiquotes, is a grab bag of various stuff without any central theme. --- src/compiler/scala/{tools => }/reflect/quasiquotes/Holes.scala | 2 +- .../scala/{tools => }/reflect/quasiquotes/Parsers.scala | 2 +- .../scala/{tools => }/reflect/quasiquotes/Placeholders.scala | 2 +- .../scala/{tools => }/reflect/quasiquotes/Quasiquotes.scala | 2 +- .../scala/{tools => }/reflect/quasiquotes/Reifiers.scala | 2 +- src/compiler/scala/tools/reflect/FastTrack.scala | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) rename src/compiler/scala/{tools => }/reflect/quasiquotes/Holes.scala (99%) rename src/compiler/scala/{tools => }/reflect/quasiquotes/Parsers.scala (99%) rename src/compiler/scala/{tools => }/reflect/quasiquotes/Placeholders.scala (99%) rename src/compiler/scala/{tools => }/reflect/quasiquotes/Quasiquotes.scala (98%) rename src/compiler/scala/{tools => }/reflect/quasiquotes/Reifiers.scala (99%) diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Holes.scala b/src/compiler/scala/reflect/quasiquotes/Holes.scala similarity index 99% rename from src/compiler/scala/tools/reflect/quasiquotes/Holes.scala rename to src/compiler/scala/reflect/quasiquotes/Holes.scala index 68cc728eb3ce..38b05f9d4b08 100644 --- a/src/compiler/scala/tools/reflect/quasiquotes/Holes.scala +++ b/src/compiler/scala/reflect/quasiquotes/Holes.scala @@ -1,4 +1,4 @@ -package scala.tools.reflect +package scala.reflect package quasiquotes import scala.collection.{immutable, mutable} diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala b/src/compiler/scala/reflect/quasiquotes/Parsers.scala similarity index 99% rename from src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala rename to src/compiler/scala/reflect/quasiquotes/Parsers.scala index 392b7fc8816c..007bac27da95 100644 --- a/src/compiler/scala/tools/reflect/quasiquotes/Parsers.scala +++ b/src/compiler/scala/reflect/quasiquotes/Parsers.scala @@ -1,4 +1,4 @@ -package scala.tools.reflect +package scala.reflect package quasiquotes import scala.tools.nsc.ast.parser.{Parsers => ScalaParser} diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Placeholders.scala b/src/compiler/scala/reflect/quasiquotes/Placeholders.scala similarity index 99% rename from src/compiler/scala/tools/reflect/quasiquotes/Placeholders.scala rename to src/compiler/scala/reflect/quasiquotes/Placeholders.scala index b287971815cf..a5b42f8a1fe2 100644 --- a/src/compiler/scala/tools/reflect/quasiquotes/Placeholders.scala +++ b/src/compiler/scala/reflect/quasiquotes/Placeholders.scala @@ -1,4 +1,4 @@ -package scala.tools.reflect +package scala.reflect package quasiquotes import java.util.UUID.randomUUID diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Quasiquotes.scala b/src/compiler/scala/reflect/quasiquotes/Quasiquotes.scala similarity index 98% rename from src/compiler/scala/tools/reflect/quasiquotes/Quasiquotes.scala rename to src/compiler/scala/reflect/quasiquotes/Quasiquotes.scala index b33069181cc0..72e6000e9fe6 100644 --- a/src/compiler/scala/tools/reflect/quasiquotes/Quasiquotes.scala +++ b/src/compiler/scala/reflect/quasiquotes/Quasiquotes.scala @@ -1,4 +1,4 @@ -package scala.tools.reflect +package scala.reflect package quasiquotes import scala.reflect.macros.runtime.Context diff --git a/src/compiler/scala/tools/reflect/quasiquotes/Reifiers.scala b/src/compiler/scala/reflect/quasiquotes/Reifiers.scala similarity index 99% rename from src/compiler/scala/tools/reflect/quasiquotes/Reifiers.scala rename to src/compiler/scala/reflect/quasiquotes/Reifiers.scala index 95113d5b004d..07becdc3c617 100644 --- a/src/compiler/scala/tools/reflect/quasiquotes/Reifiers.scala +++ b/src/compiler/scala/reflect/quasiquotes/Reifiers.scala @@ -1,4 +1,4 @@ -package scala.tools.reflect +package scala.reflect package quasiquotes import java.lang.UnsupportedOperationException diff --git a/src/compiler/scala/tools/reflect/FastTrack.scala b/src/compiler/scala/tools/reflect/FastTrack.scala index 64cf3d0847f0..8fed53c89fb0 100644 --- a/src/compiler/scala/tools/reflect/FastTrack.scala +++ b/src/compiler/scala/tools/reflect/FastTrack.scala @@ -5,7 +5,7 @@ import scala.reflect.reify.Taggers import scala.tools.nsc.typechecker.{ Analyzer, Macros } import scala.reflect.runtime.Macros.currentMirror import scala.reflect.api.Universe -import scala.tools.reflect.quasiquotes.{ Quasiquotes => QuasiquoteImpls } +import scala.reflect.quasiquotes.{ Quasiquotes => QuasiquoteImpls } /** Optimizes system macro expansions by hardwiring them directly to their implementations * bypassing standard reflective load and invoke to avoid the overhead of Java/Scala reflection. From 3b35177e7620da91e8c77ed5d16ef168b64e58b8 Mon Sep 17 00:00:00 2001 From: Eugene Burmako Date: Thu, 11 Sep 2014 14:56:13 +0200 Subject: [PATCH 542/826] This ensures that typechecking custom unapplications in silent mode doesn't leak uncatchable errors. Interestingly enough, the problem only manifested itself for custom unapply methods, not for synthetic ones generated for case classes. --- .../scala/tools/nsc/transform/UnCurry.scala | 2 +- .../transform/patmat/MatchTranslation.scala | 4 ++-- .../patmat/ScalacPatternExpanders.scala | 17 ++++++++------- .../tools/nsc/typechecker/PatternTypers.scala | 2 +- test/files/pos/t8719.check | 0 test/files/pos/t8719/Macros_1.scala | 21 +++++++++++++++++++ test/files/pos/t8719/Test_2.scala | 10 +++++++++ 7 files changed, 44 insertions(+), 12 deletions(-) create mode 100644 test/files/pos/t8719.check create mode 100644 test/files/pos/t8719/Macros_1.scala create mode 100644 test/files/pos/t8719/Test_2.scala diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala index 9b85f1b36ab0..3544dc9966d9 100644 --- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala +++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala @@ -459,7 +459,7 @@ abstract class UnCurry extends InfoTransform case UnApply(fn, args) => val fn1 = transform(fn) val args1 = fn.symbol.name match { - case nme.unapplySeq => transformArgs(tree.pos, fn.symbol, args, patmat.alignPatterns(tree).expectedTypes) + case nme.unapplySeq => transformArgs(tree.pos, fn.symbol, args, patmat.alignPatterns(global.typer.context, tree).expectedTypes) case _ => args } treeCopy.UnApply(tree, fn1, args1) diff --git a/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala b/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala index 0eaffe7ceeee..d862805a07c7 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala @@ -377,8 +377,8 @@ trait MatchTranslation { object ExtractorCall { // TODO: check unargs == args def apply(tree: Tree): ExtractorCall = tree match { - case UnApply(unfun, args) => new ExtractorCallRegular(alignPatterns(tree), unfun, args) // extractor - case Apply(fun, args) => new ExtractorCallProd(alignPatterns(tree), fun, args) // case class + case UnApply(unfun, args) => new ExtractorCallRegular(alignPatterns(context, tree), unfun, args) // extractor + case Apply(fun, args) => new ExtractorCallProd(alignPatterns(context, tree), fun, args) // case class } } diff --git a/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala b/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala index 8f21f4ecfcba..79f5e3bee87b 100644 --- a/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala +++ b/src/compiler/scala/tools/nsc/transform/patmat/ScalacPatternExpanders.scala @@ -18,6 +18,7 @@ trait ScalacPatternExpanders { import global._ import definitions._ import treeInfo._ + import analyzer._ type PatternAligned = ScalacPatternExpander#Aligned @@ -94,7 +95,7 @@ trait ScalacPatternExpanders { def tupleExtractor(extractor: Extractor): Extractor = extractor.copy(fixed = tupleType(extractor.fixed) :: Nil) - private def validateAligned(tree: Tree, aligned: Aligned): Aligned = { + private def validateAligned(context: Context, tree: Tree, aligned: Aligned): Aligned = { import aligned._ def owner = tree.symbol.owner @@ -103,8 +104,8 @@ trait ScalacPatternExpanders { def offerString = if (extractor.isErroneous) "" else s" offering $offering" def arityExpected = ( if (extractor.hasSeq) "at least " else "" ) + productArity - def err(msg: String) = reporter.error(tree.pos, msg) - def warn(msg: String) = reporter.warning(tree.pos, msg) + def err(msg: String) = context.error(tree.pos, msg) + def warn(msg: String) = context.warning(tree.pos, msg) def arityError(what: String) = err(s"$what patterns for $owner$offerString: expected $arityExpected, found $totalArity") if (isStar && !isSeq) @@ -117,7 +118,7 @@ trait ScalacPatternExpanders { aligned } - def apply(sel: Tree, args: List[Tree]): Aligned = { + def apply(context: Context, sel: Tree, args: List[Tree]): Aligned = { val fn = sel match { case Unapplied(fn) => fn case _ => sel @@ -145,12 +146,12 @@ trait ScalacPatternExpanders { } val normalizedExtractor = if (requiresTupling) tupleExtractor(extractor) else extractor - validateAligned(fn, Aligned(patterns, normalizedExtractor)) + validateAligned(context, fn, Aligned(patterns, normalizedExtractor)) } - def apply(tree: Tree): Aligned = tree match { - case Apply(fn, args) => apply(fn, args) - case UnApply(fn, args) => apply(fn, args) + def apply(context: Context, tree: Tree): Aligned = tree match { + case Apply(fn, args) => apply(context, fn, args) + case UnApply(fn, args) => apply(context, fn, args) } } } diff --git a/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala b/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala index da0e67a2a523..bb8c3c3c6d95 100644 --- a/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala +++ b/src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala @@ -309,7 +309,7 @@ trait PatternTypers { // the union of the expected type and the inferred type of the argument to unapply val glbType = glb(ensureFullyDefined(pt) :: unapplyArg.tpe_* :: Nil) val wrapInTypeTest = canRemedy && !(fun1.symbol.owner isNonBottomSubClass ClassTagClass) - val formals = patmat.alignPatterns(fun1, args).unexpandedFormals + val formals = patmat.alignPatterns(context.asInstanceOf[analyzer.Context], fun1, args).unexpandedFormals val args1 = typedArgsForFormals(args, formals, mode) val result = UnApply(fun1, args1) setPos tree.pos setType glbType diff --git a/test/files/pos/t8719.check b/test/files/pos/t8719.check new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/test/files/pos/t8719/Macros_1.scala b/test/files/pos/t8719/Macros_1.scala new file mode 100644 index 000000000000..152c92f25483 --- /dev/null +++ b/test/files/pos/t8719/Macros_1.scala @@ -0,0 +1,21 @@ +import scala.language.experimental.macros +import scala.reflect.macros.TypecheckException +import scala.reflect.macros.whitebox.Context + +object Macros { + def typecheck_impl(c: Context)(code: c.Expr[String]): c.Expr[Option[String]] = { + import c.universe._ + + val Expr(Literal(Constant(codeStr: String))) = code + + try { + c.typecheck(c.parse(codeStr)) + c.Expr(q"None: Option[String]") + } catch { + case e: TypecheckException => + c.Expr(q"Some(${ e.toString }): Option[String]") + } + } + + def typecheck(code: String): Option[String] = macro typecheck_impl +} \ No newline at end of file diff --git a/test/files/pos/t8719/Test_2.scala b/test/files/pos/t8719/Test_2.scala new file mode 100644 index 000000000000..997eb2f23652 --- /dev/null +++ b/test/files/pos/t8719/Test_2.scala @@ -0,0 +1,10 @@ +case class Foo(i: Int, c: Char) + +object Bar { + def unapply(foo: Foo): Option[(Int, Char)] = Some((foo.i, foo.c)) +} + +object Test extends App { + println(Macros.typecheck("val Foo(x, y, z) = Foo(1, 'a')")) + println(Macros.typecheck("val Bar(x, y, z) = Foo(1, 'a')")) +} \ No newline at end of file From b416dc6be9079bd9940d0585c49a12288020dcdf Mon Sep 17 00:00:00 2001 From: terma Date: Thu, 11 Sep 2014 16:40:49 -0400 Subject: [PATCH 543/826] SI-8817 Correct scaladoc for scala.sys.addShutdownHook - Remove mention that shutdown hook is daemon thread - Add link on scala.sys.ShutdownHookThread class --- src/library/scala/sys/package.scala | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/library/scala/sys/package.scala b/src/library/scala/sys/package.scala index 386bd841130d..e493603bc24e 100644 --- a/src/library/scala/sys/package.scala +++ b/src/library/scala/sys/package.scala @@ -61,16 +61,15 @@ package object sys { def env: immutable.Map[String, String] = immutable.Map(System.getenv().asScala.toSeq: _*) /** Register a shutdown hook to be run when the VM exits. - * The newly created thread is marked as a daemon so it will not - * interfere with VM shutdown. The hook is automatically registered: - * the returned value can be ignored, but is available in case the - * Thread requires further modification. It can also be unregistered - * by calling ShutdownHookThread#remove(). + * The hook is automatically registered: the returned value can be ignored, + * but is available in case the Thread requires further modification. + * It can also be unregistered by calling ShutdownHookThread#remove(). * * Note that shutdown hooks are NOT guaranteed to be run. * * @param body the body of code to run at shutdown * @return the Thread which will run the shutdown hook. + * @see [[scala.sys.ShutdownHookThread]] */ def addShutdownHook(body: => Unit): ShutdownHookThread = ShutdownHookThread(body) From 1da69e82a1ccf2327b337068de1209d772cb6b52 Mon Sep 17 00:00:00 2001 From: Rex Kerr Date: Sun, 24 Aug 2014 17:55:20 -0700 Subject: [PATCH 544/826] SI-8815 mutable.LongMap makes different choices for splitAt vs etc. It turns out that take/drop/splitAt/takeWhile/dropWhile inherit a smattering of foreach vs. iterator-based implementations. These aren't consistent unless they iterate in the same order. This probably reflects an undesirable underlying weakness, but in this particular case it was easy to make LongMap's foreach order agree with iterator. Made traversal order of other foreach-like methods match also. Also fixed a bug where Long.MinValue wasn't iterated. Added unit test for iteration coverage of extreme values. --- .../scala/collection/mutable/LongMap.scala | 38 ++++++------------- .../collection/SetMapConsistencyTest.scala | 15 ++++++++ 2 files changed, 26 insertions(+), 27 deletions(-) diff --git a/src/library/scala/collection/mutable/LongMap.scala b/src/library/scala/collection/mutable/LongMap.scala index 984ae6f7ccb8..ef488a3697c6 100644 --- a/src/library/scala/collection/mutable/LongMap.scala +++ b/src/library/scala/collection/mutable/LongMap.scala @@ -388,12 +388,14 @@ extends AbstractMap[Long, V] nextPair = anotherPair anotherPair = null } - nextPair = null + else nextPair = null ans } } override def foreach[A](f: ((Long,V)) => A) { + if ((extraKeys & 1) == 1) f((0L, zeroValue.asInstanceOf[V])) + if ((extraKeys & 2) == 2) f((Long.MinValue, minValue.asInstanceOf[V])) var i,j = 0 while (i < _keys.length & j < _size) { val k = _keys(i) @@ -403,8 +405,6 @@ extends AbstractMap[Long, V] } i += 1 } - if ((extraKeys & 1) == 1) f((0L, zeroValue.asInstanceOf[V])) - if ((extraKeys & 2) == 2) f((Long.MinValue, minValue.asInstanceOf[V])) } override def clone(): LongMap[V] = { @@ -417,6 +417,8 @@ extends AbstractMap[Long, V] /** Applies a function to all keys of this map. */ def foreachKey[A](f: Long => A) { + if ((extraKeys & 1) == 1) f(0L) + if ((extraKeys & 2) == 2) f(Long.MinValue) var i,j = 0 while (i < _keys.length & j < _size) { val k = _keys(i) @@ -426,12 +428,12 @@ extends AbstractMap[Long, V] } i += 1 } - if ((extraKeys & 1) == 1) f(0L) - if ((extraKeys & 2) == 2) f(Long.MinValue) } /** Applies a function to all values of this map. */ def foreachValue[A](f: V => A) { + if ((extraKeys & 1) == 1) f(zeroValue.asInstanceOf[V]) + if ((extraKeys & 2) == 2) f(minValue.asInstanceOf[V]) var i,j = 0 while (i < _keys.length & j < _size) { val k = _keys(i) @@ -441,8 +443,6 @@ extends AbstractMap[Long, V] } i += 1 } - if ((extraKeys & 1) == 1) f(zeroValue.asInstanceOf[V]) - if ((extraKeys & 2) == 2) f(minValue.asInstanceOf[V]) } /** Creates a new `LongMap` with different values. @@ -450,6 +450,8 @@ extends AbstractMap[Long, V] * collection immediately. */ def mapValuesNow[V1](f: V => V1): LongMap[V1] = { + val zv = if ((extraKeys & 1) == 1) f(zeroValue.asInstanceOf[V]).asInstanceOf[AnyRef] else null + val mv = if ((extraKeys & 2) == 2) f(minValue.asInstanceOf[V]).asInstanceOf[AnyRef] else null val lm = new LongMap[V1](LongMap.exceptionDefault, 1, false) val kz = java.util.Arrays.copyOf(_keys, _keys.length) val vz = new Array[AnyRef](_values.length) @@ -462,8 +464,6 @@ extends AbstractMap[Long, V] } i += 1 } - val zv = if ((extraKeys & 1) == 1) f(zeroValue.asInstanceOf[V]).asInstanceOf[AnyRef] else null - val mv = if ((extraKeys & 2) == 2) f(minValue.asInstanceOf[V]).asInstanceOf[AnyRef] else null lm.initializeTo(mask, extraKeys, zv, mv, _size, _vacant, kz, vz) lm } @@ -472,6 +472,8 @@ extends AbstractMap[Long, V] * Note: the default, if any, is not transformed. */ def transformValues(f: V => V): this.type = { + if ((extraKeys & 1) == 1) zeroValue = f(zeroValue.asInstanceOf[V]).asInstanceOf[AnyRef] + if ((extraKeys & 2) == 2) minValue = f(minValue.asInstanceOf[V]).asInstanceOf[AnyRef] var i,j = 0 while (i < _keys.length & j < _size) { val k = _keys(i) @@ -481,26 +483,8 @@ extends AbstractMap[Long, V] } i += 1 } - if ((extraKeys & 1) == 1) zeroValue = f(zeroValue.asInstanceOf[V]).asInstanceOf[AnyRef] - if ((extraKeys & 2) == 2) minValue = f(minValue.asInstanceOf[V]).asInstanceOf[AnyRef] this } - - /* - override def toString = { - val sb = new StringBuilder("LongMap(") - var n = 0 - foreach{ case (k,v) => - if (n > 0) sb ++= ", " - sb ++= k.toString - sb ++= " -> " - sb ++= v.toString - n += 1 - } - sb += ')' - sb.result - } - */ } object LongMap { diff --git a/test/junit/scala/collection/SetMapConsistencyTest.scala b/test/junit/scala/collection/SetMapConsistencyTest.scala index eed6007eef24..261c11a98bc5 100644 --- a/test/junit/scala/collection/SetMapConsistencyTest.scala +++ b/test/junit/scala/collection/SetMapConsistencyTest.scala @@ -514,4 +514,19 @@ class SetMapConsistencyTest { assert( hs.toList.toSet == hs ) assert( hs == hs.toList.toSet ) } + + @Test + def testSI8815() { + val lm = new scala.collection.mutable.LongMap[String] + lm += (Long.MinValue, "min") + lm += (-1, "neg-one") + lm += (0, "zero") + lm += (Long.MaxValue, "max") + var nit = 0 + lm.iterator.foreach(_ => nit += 1) + var nfe = 0 + lm.foreach(_ => nfe += 1) + assert(nit == 4) + assert(nfe == 4) + } } From 63207e115a46634d47446a87a7f4bc3c2651b0e7 Mon Sep 17 00:00:00 2001 From: Lukas Rytz Date: Wed, 10 Sep 2014 13:59:03 +0200 Subject: [PATCH 545/826] isAnonymousClass/Function for delambdafy classes is not true Ydelambdafy:method lambda classes are not anonymous classes, and not anonymous function classes either. They are somethig new, so there's a new predicate isDelambdafyFunction. They are not anonymous classes (or functions) because anonymous classes in Java speak are nested. Delambdafy classes are always top-level, they are just synthetic. Before this patch, isAnonymous was sometimes accidentailly true: if the lambda is nested in an anonymous class. Now it's always false. --- build.xml | 9 ++++-- .../nsc/backend/jvm/BCodeAsmCommon.scala | 13 ++++----- .../tools/nsc/transform/Delambdafy.scala | 28 +++++++++++-------- .../scala/reflect/internal/StdNames.scala | 23 +++++++-------- .../scala/reflect/internal/Symbols.scala | 1 + .../run/delambdafyLambdaClassNames.check | 1 + .../run/delambdafyLambdaClassNames.flags | 1 + .../run/delambdafyLambdaClassNames/A_1.scala | 5 ++++ .../run/delambdafyLambdaClassNames/Test.scala | 4 +++ 9 files changed, 52 insertions(+), 33 deletions(-) create mode 100644 test/files/run/delambdafyLambdaClassNames.check create mode 100644 test/files/run/delambdafyLambdaClassNames.flags create mode 100644 test/files/run/delambdafyLambdaClassNames/A_1.scala create mode 100644 test/files/run/delambdafyLambdaClassNames/Test.scala diff --git a/build.xml b/build.xml index 6c750e530df5..944feb2c1075 100755 --- a/build.xml +++ b/build.xml @@ -1512,7 +1512,12 @@ TODO: - + + + + + + @@ -1530,7 +1535,7 @@ TODO: - + diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala index e5b4c4a6c21f..0c0d726630c4 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala @@ -22,14 +22,11 @@ final class BCodeAsmCommon[G <: Global](val global: G) { * null. */ def isAnonymousOrLocalClass(classSym: Symbol): Boolean = { - def isDelambdafyLambdaClass(classSym: Symbol): Boolean = { - classSym.isAnonymousFunction && (settings.Ydelambdafy.value == "method") - } - assert(classSym.isClass, s"not a class: $classSym") - - !isDelambdafyLambdaClass(classSym) && - (classSym.isAnonymousClass || !classSym.originalOwner.isClass) + val res = (classSym.isAnonymousClass || !classSym.originalOwner.isClass) + // lambda classes are always top-level classes. + if (res) assert(!classSym.isDelambdafyFunction) + res } /** @@ -81,7 +78,7 @@ final class BCodeAsmCommon[G <: Global](val global: G) { final case class EnclosingMethodEntry(owner: String, name: String, methodDescriptor: String) /** - * If data for emitting an EnclosingMethod attribute. None if `classSym` is a member class (not + * Data for emitting an EnclosingMethod attribute. None if `classSym` is a member class (not * an anonymous or local class). See doc in BTypes. * * The class is parametrized by two functions to obtain a bytecode class descriptor for a class diff --git a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala index 9cc8d779a0ff..12e7b23f48b3 100644 --- a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala +++ b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala @@ -245,18 +245,22 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre // - make `anonClass.isAnonymousClass` true. // - use `newAnonymousClassSymbol` or push the required variations into a similar factory method // - reinstate the assertion in `Erasure.resolveAnonymousBridgeClash` - val suffix = "$lambda$" + ( + val suffix = nme.DELAMBDAFY_LAMBDA_CLASS_NAME + "$" + ( if (funOwner.isPrimaryConstructor) "" else "$" + funOwner.name + "$" ) - val name = unit.freshTypeName(s"${oldClass.name.decode}$suffix") + val oldClassPart = oldClass.name.decode + // make sure the class name doesn't contain $anon, otherwsie isAnonymousClass/Function may be true + val name = unit.freshTypeName(s"$oldClassPart$suffix".replace("$anon", "$nestedInAnon")) - val anonClass = pkg newClassSymbol(name, originalFunction.pos, FINAL | SYNTHETIC) addAnnotation SerialVersionUIDAnnotation - anonClass setInfo ClassInfoType(parents, newScope, anonClass) + val lambdaClass = pkg newClassSymbol(name, originalFunction.pos, FINAL | SYNTHETIC) addAnnotation SerialVersionUIDAnnotation + lambdaClass setInfo ClassInfoType(parents, newScope, lambdaClass) + assert(!lambdaClass.isAnonymousClass && !lambdaClass.isAnonymousFunction, "anonymous class name: "+ lambdaClass.name) + assert(lambdaClass.isDelambdafyFunction, "not lambda class name: " + lambdaClass.name) val captureProxies2 = new LinkedHashMap[Symbol, TermSymbol] captures foreach {capture => - val sym = anonClass.newVariable(capture.name.toTermName, capture.pos, SYNTHETIC) + val sym = lambdaClass.newVariable(capture.name.toTermName, capture.pos, SYNTHETIC) sym setInfo capture.info captureProxies2 += ((capture, sym)) } @@ -266,30 +270,30 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre val thisProxy = { val target = targetMethod(originalFunction) if (thisReferringMethods contains target) { - val sym = anonClass.newVariable(nme.FAKE_LOCAL_THIS, originalFunction.pos, SYNTHETIC) + val sym = lambdaClass.newVariable(nme.FAKE_LOCAL_THIS, originalFunction.pos, SYNTHETIC) sym.info = oldClass.tpe sym } else NoSymbol } - val decapturify = new DeCapturifyTransformer(captureProxies2, unit, oldClass, anonClass, originalFunction.symbol.pos, thisProxy) + val decapturify = new DeCapturifyTransformer(captureProxies2, unit, oldClass, lambdaClass, originalFunction.symbol.pos, thisProxy) val accessorMethod = createAccessorMethod(thisProxy, originalFunction) val decapturedFunction = decapturify.transform(originalFunction).asInstanceOf[Function] val members = (optionSymbol(thisProxy).toList ++ (captureProxies2 map (_._2))) map {member => - anonClass.info.decls enter member + lambdaClass.info.decls enter member ValDef(member, gen.mkZero(member.tpe)) setPos decapturedFunction.pos } // constructor - val constr = createConstructor(anonClass, members) + val constr = createConstructor(lambdaClass, members) // apply method with same arguments and return type as original lambda. - val applyMethodDef = createApplyMethod(anonClass, decapturedFunction, accessorMethod, thisProxy) + val applyMethodDef = createApplyMethod(lambdaClass, decapturedFunction, accessorMethod, thisProxy) - val bridgeMethod = createBridgeMethod(anonClass, originalFunction, applyMethodDef) + val bridgeMethod = createBridgeMethod(lambdaClass, originalFunction, applyMethodDef) def fulldef(sym: Symbol) = if (sym == NoSymbol) sym.toString @@ -305,7 +309,7 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre val body = members ++ List(constr, applyMethodDef) ++ bridgeMethod // TODO if member fields are private this complains that they're not accessible - (localTyper.typedPos(decapturedFunction.pos)(ClassDef(anonClass, body)).asInstanceOf[ClassDef], thisProxy, accessorMethod) + (localTyper.typedPos(decapturedFunction.pos)(ClassDef(lambdaClass, body)).asInstanceOf[ClassDef], thisProxy, accessorMethod) } val (anonymousClassDef, thisProxy, accessorMethod) = makeAnonymousClass diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala index d203218c0978..99ff6a10b440 100644 --- a/src/reflect/scala/reflect/internal/StdNames.scala +++ b/src/reflect/scala/reflect/internal/StdNames.scala @@ -99,17 +99,18 @@ trait StdNames { val SINGLETON_SUFFIX: String = ".type" - val ANON_CLASS_NAME: NameType = "$anon" - val ANON_FUN_NAME: NameType = "$anonfun" - val EMPTY: NameType = "" - val EMPTY_PACKAGE_NAME: NameType = "" - val IMPL_CLASS_SUFFIX = "$class" - val IMPORT: NameType = "" - val MODULE_SUFFIX_NAME: NameType = MODULE_SUFFIX_STRING - val MODULE_VAR_SUFFIX: NameType = "$module" - val PACKAGE: NameType = "package" - val ROOT: NameType = "" - val SPECIALIZED_SUFFIX: NameType = "$sp" + val ANON_CLASS_NAME: NameType = "$anon" + val DELAMBDAFY_LAMBDA_CLASS_NAME: NameType = "$lambda" + val ANON_FUN_NAME: NameType = "$anonfun" + val EMPTY: NameType = "" + val EMPTY_PACKAGE_NAME: NameType = "" + val IMPL_CLASS_SUFFIX = "$class" + val IMPORT: NameType = "" + val MODULE_SUFFIX_NAME: NameType = MODULE_SUFFIX_STRING + val MODULE_VAR_SUFFIX: NameType = "$module" + val PACKAGE: NameType = "package" + val ROOT: NameType = "" + val SPECIALIZED_SUFFIX: NameType = "$sp" // value types (and AnyRef) are all used as terms as well // as (at least) arguments to the @specialize annotation. diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala index 2670faa22d17..44fce2c9ab2b 100644 --- a/src/reflect/scala/reflect/internal/Symbols.scala +++ b/src/reflect/scala/reflect/internal/Symbols.scala @@ -789,6 +789,7 @@ trait Symbols extends api.Symbols { self: SymbolTable => isMethod && owner.isDerivedValueClass && !isParamAccessor && !isConstructor && !hasFlag(SUPERACCESSOR) && !isMacro && !isSpecialized final def isAnonymousFunction = isSynthetic && (name containsName tpnme.ANON_FUN_NAME) + final def isDelambdafyFunction = isSynthetic && (name containsName tpnme.DELAMBDAFY_LAMBDA_CLASS_NAME) final def isDefinedInPackage = effectiveOwner.isPackageClass final def needsFlatClasses = phase.flatClasses && rawowner != NoSymbol && !rawowner.isPackageClass diff --git a/test/files/run/delambdafyLambdaClassNames.check b/test/files/run/delambdafyLambdaClassNames.check new file mode 100644 index 000000000000..d425d15dd0b6 --- /dev/null +++ b/test/files/run/delambdafyLambdaClassNames.check @@ -0,0 +1 @@ +A$$nestedInAnon$1$lambda$$run$1 diff --git a/test/files/run/delambdafyLambdaClassNames.flags b/test/files/run/delambdafyLambdaClassNames.flags new file mode 100644 index 000000000000..b10233d3226f --- /dev/null +++ b/test/files/run/delambdafyLambdaClassNames.flags @@ -0,0 +1 @@ +-Ybackend:GenBCode -Ydelambdafy:method \ No newline at end of file diff --git a/test/files/run/delambdafyLambdaClassNames/A_1.scala b/test/files/run/delambdafyLambdaClassNames/A_1.scala new file mode 100644 index 000000000000..10489414b77d --- /dev/null +++ b/test/files/run/delambdafyLambdaClassNames/A_1.scala @@ -0,0 +1,5 @@ +class A { + def f = new Runnable { + def run(): Unit = List(1,2).foreach(println) + } +} diff --git a/test/files/run/delambdafyLambdaClassNames/Test.scala b/test/files/run/delambdafyLambdaClassNames/Test.scala new file mode 100644 index 000000000000..49a397d1d2b8 --- /dev/null +++ b/test/files/run/delambdafyLambdaClassNames/Test.scala @@ -0,0 +1,4 @@ +object Test extends App { + val c = Class.forName("A$$nestedInAnon$1$lambda$$run$1") + println(c.getName) +} From 039f3e3b35f73886f79f00bc578739002fe034cc Mon Sep 17 00:00:00 2001 From: Rex Kerr Date: Sat, 28 Jun 2014 03:24:39 -0700 Subject: [PATCH 546/826] SI-8680 Stream.addString is too eager Used the standard method of sending out two iterators, one twice as fast as the others, to avoid hanging on .force, .hasDefiniteSize, and .addString. .addString appends a "..." as the last element if it detects a cycle. It knows how to print the cycle length, but there's no good way to specify what you want right now, so it's not used. Added tests in t8680 that verify that cyclic streams give the expected results. Added to whitelist names of methods formerly used for recursion (now looping). --- bincompat-backward.whitelist.conf | 13 ++ bincompat-forward.whitelist.conf | 21 +++ .../scala/collection/immutable/Stream.scala | 125 ++++++++++++++++-- test/files/run/t8680.scala | 53 ++++++++ 4 files changed, 198 insertions(+), 14 deletions(-) create mode 100644 test/files/run/t8680.scala diff --git a/bincompat-backward.whitelist.conf b/bincompat-backward.whitelist.conf index 1c48887b63a9..6c98dc62a18f 100644 --- a/bincompat-backward.whitelist.conf +++ b/bincompat-backward.whitelist.conf @@ -194,6 +194,19 @@ filter { { matchName="scala.collection.immutable.Stream.filteredTail" problemName=MissingMethodProblem + }, + // https://github.com/scala/scala/pull/3848 -- SI-8680 + { + matchName="scala.collection.immutable.Stream.scala$collection$immutable$Stream$$loop$6" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.immutable.Stream.scala$collection$immutable$Stream$$loop$5" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.immutable.Stream.scala$collection$immutable$Stream$$loop$4" + problemName=MissingMethodProblem } ] } diff --git a/bincompat-forward.whitelist.conf b/bincompat-forward.whitelist.conf index ec80e7cce951..87a59f2d536a 100644 --- a/bincompat-forward.whitelist.conf +++ b/bincompat-forward.whitelist.conf @@ -368,6 +368,27 @@ filter { { matchName="scala.reflect.io.AbstractFile.filterImpl" problemName=MissingMethodProblem + }, + // https://github.com/scala/scala/pull/3848 -- SI-8680 + { + matchName="scala.collection.immutable.Stream.scala$collection$immutable$Stream$$loop$6" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.immutable.Stream.scala$collection$immutable$Stream$$loop$5" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.immutable.Stream.scala$collection$immutable$Stream$$loop$4" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.immutable.Stream.scala$collection$immutable$Stream$$loop$3" + problemName=MissingMethodProblem + }, + { + matchName="scala.collection.immutable.Stream.scala$collection$immutable$Stream$$loop$2" + problemName=MissingMethodProblem } ] } diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala index 1f97c4c76925..91a4e1c43d3a 100644 --- a/src/library/scala/collection/immutable/Stream.scala +++ b/src/library/scala/collection/immutable/Stream.scala @@ -176,6 +176,12 @@ import scala.language.implicitConversions * loop(1, 1) * } * }}} + * + * Note that `mkString` forces evaluation of a `Stream`, but `addString` does + * not. In both cases, a `Stream` that is or ends in a cycle + * (e.g. `lazy val s: Stream[Int] = 0 #:: s`) will convert additional trips + * through the cycle to `...`. Additionally, `addString` will display an + * un-memoized tail as `?`. * * @tparam A the type of the elements contained in this stream. * @@ -253,12 +259,22 @@ self => * @note Often we use `Stream`s to represent an infinite set or series. If * that's the case for your particular `Stream` then this function will never * return and will probably crash the VM with an `OutOfMemory` exception. + * This function will not hang on a finite cycle, however. * * @return The fully realized `Stream`. */ def force: Stream[A] = { - var these = this - while (!these.isEmpty) these = these.tail + // Use standard 2x 1x iterator trick for cycle detection ("those" is slow one) + var these, those = this + if (!these.isEmpty) these = these.tail + while (those ne these) { + if (these.isEmpty) return this + these = these.tail + if (these.isEmpty) return this + these = these.tail + if (these eq those) return this + those = those.tail + } this } @@ -309,9 +325,24 @@ self => override def toStream: Stream[A] = this - override def hasDefiniteSize = { - def loop(s: Stream[A]): Boolean = s.isEmpty || s.tailDefined && loop(s.tail) - loop(this) + override def hasDefiniteSize: Boolean = isEmpty || { + if (!tailDefined) false + else { + // Two-iterator trick (2x & 1x speed) for cycle detection. + var those = this + var these = tail + while (those ne these) { + if (these.isEmpty) return true + if (!these.tailDefined) return false + these = these.tail + if (these.isEmpty) return true + if (!these.tailDefined) return false + these = these.tail + if (those eq these) return false + those = those.tail + } + false // Cycle detected + } } /** Create a new stream which contains all elements of this stream followed by @@ -690,7 +721,8 @@ self => * `end`. Inside, the string representations of defined elements (w.r.t. * the method `toString()`) are separated by the string `sep`. The method will * not force evaluation of undefined elements. A tail of such elements will be - * represented by a `"?"` instead. + * represented by a `"?"` instead. A cyclic stream is represented by a `"..."` + * at the point where the cycle repeats. * * @param b The [[collection.mutable.StringBuilder]] factory to which we need * to add the string elements. @@ -701,16 +733,81 @@ self => * resulting string. */ override def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder = { - def loop(pre: String, these: Stream[A]) { - if (these.isEmpty) b append end - else { - b append pre append these.head - if (these.tailDefined) loop(sep, these.tail) - else b append sep append "?" append end + b append start + if (!isEmpty) { + b append head + var cursor = this + var n = 1 + if (cursor.tailDefined) { // If tailDefined, also !isEmpty + var scout = tail + if (scout.isEmpty) { + // Single element. Bail out early. + b append end + return b + } + if ((cursor ne scout) && scout.tailDefined) { + cursor = scout + scout = scout.tail + // Use 2x 1x iterator trick for cycle detection; slow iterator can add strings + while ((cursor ne scout) && scout.tailDefined) { + b append sep append cursor.head + n += 1 + cursor = cursor.tail + scout = scout.tail + if (scout.tailDefined) scout = scout.tail + } + } + if (!scout.tailDefined) { // Not a cycle, scout hit an end + while (cursor ne scout) { + b append sep append cursor.head + n += 1 + cursor = cursor.tail + } + } + else { + // Cycle. + // If we have a prefix of length P followed by a cycle of length C, + // the scout will be at position (P%C) in the cycle when the cursor + // enters it at P. They'll then collide when the scout advances another + // C - (P%C) ahead of the cursor. + // If we run the scout P farther, then it will be at the start of + // the cycle: (C - (P%C) + (P%C)) == C == 0. So if another runner + // starts at the beginning of the prefix, they'll collide exactly at + // the start of the loop. + var runner = this + var k = 0 + while (runner ne scout) { + runner = runner.tail + scout = scout.tail + k += 1 + } + // Now runner and scout are at the beginning of the cycle. Advance + // cursor, adding to string, until it hits; then we'll have covered + // everything once. If cursor is already at beginning, we'd better + // advance one first unless runner didn't go anywhere (in which case + // we've already looped once). + if ((cursor eq scout) && (k > 0)) { + b append sep append cursor.head + n += 1 + cursor = cursor.tail + } + while (cursor ne scout) { + b append sep append cursor.head + n += 1 + cursor = cursor.tail + } + // Subtract prefix length from total length for cycle reporting. + // (Not currently used, but probably a good idea for the future.) + n -= k + } + } + if (!cursor.isEmpty) { + // Either undefined or cyclic; we can check with tailDefined + if (!cursor.tailDefined) b append sep append "?" + else b append sep append "..." } } - b append start - loop("", this) + b append end b } diff --git a/test/files/run/t8680.scala b/test/files/run/t8680.scala new file mode 100644 index 000000000000..2bce09c507b9 --- /dev/null +++ b/test/files/run/t8680.scala @@ -0,0 +1,53 @@ +object Test extends App { + def pre(n: Int) = (-n to -1).toStream + + def cyc(m: Int) = { + lazy val s: Stream[Int] = (0 until m).toStream #::: s + s + } + + def precyc(n: Int, m: Int) = pre(n) #::: cyc(m) + + def str(s: Stream[Int]) = { + val b = new StringBuilder + s.addString(b, "", "", "") + b.toString + } + + def goal(n: Int, m: Int) = (-n until m).mkString + "..." + + // Check un-forced cyclic and non-cyclic streams + assert(str(pre(2)) == pre(2).take(1).toList.mkString + "?") + assert(str(cyc(2)) == cyc(2).take(1).toList.mkString + "?") + assert(str(precyc(2,2)) == precyc(2,2).take(1).toList.mkString + "?") + assert(!pre(2).hasDefiniteSize) + assert(!cyc(2).hasDefiniteSize) + assert(!precyc(2,2).hasDefiniteSize) + + // Check forced cyclic and non-cyclic streams + assert(str(pre(2).force) == (-2 to -1).mkString) + assert(str(cyc(2).force) == (0 until 2).mkString + "...") + assert(str(precyc(2,2).force) == (-2 until 2).mkString + "...") + assert(pre(2).force.hasDefiniteSize) + assert(!cyc(2).force.hasDefiniteSize) + assert(!precyc(2,2).force.hasDefiniteSize) + + // Special cases + assert(str(cyc(1).force) == goal(0,1)) + assert(str(precyc(1,6).force) == goal(1,6)) + assert(str(precyc(6,1).force) == goal(6,1)) + + // Make sure there are no odd/even problems + for (n <- 3 to 4; m <- 3 to 4) { + assert(precyc(n,m).mkString == goal(n,m), s"mkString $n $m") + assert(!precyc(n,m).force.hasDefiniteSize, s"hasDef $n$m") + } + + // Make sure there are no cycle/prefix modulus problems + for (i <- 6 to 8) { + assert(precyc(i,3).mkString == goal(i,3), s"mkString $i 3") + assert(precyc(3,i).mkString == goal(3,i), s"mkString 3 $i") + assert(!precyc(i,3).force.hasDefiniteSize, s"hasDef $i 3") + assert(!precyc(3,i).force.hasDefiniteSize, s"hasDef 3 $i") + } +} From a8a31e96dd115da09236a3d8f0d761f03db866fd Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Sat, 13 Sep 2014 18:46:53 +1000 Subject: [PATCH 547/826] SI-8844 Fix regression with existentials + type aliases Regressed in 2a1b15e / SI-8283. Another specimen of an archetypal bug: unwanted dealising by using `typeSymbol`, rather than `typeSymbolDirect`. --- src/reflect/scala/reflect/internal/Types.scala | 2 +- test/files/pos/t8844.scala | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) create mode 100644 test/files/pos/t8844.scala diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala index f26315c5389c..a95f626a0b5e 100644 --- a/src/reflect/scala/reflect/internal/Types.scala +++ b/src/reflect/scala/reflect/internal/Types.scala @@ -2605,7 +2605,7 @@ trait Types // derived from the existentially quantified type into the typing environment // (aka \Gamma, which tracks types for variables and constraints/kinds for types) // as a nice bonus, delaying this until we need it avoids cyclic errors - def tpars = underlying.typeSymbol.initialize.typeParams + def tpars = underlying.typeSymbolDirect.initialize.typeParams def newSkolem(quant: Symbol) = owner.newExistentialSkolem(quant, origin) def newSharpenedSkolem(quant: Symbol, tparam: Symbol): Symbol = { diff --git a/test/files/pos/t8844.scala b/test/files/pos/t8844.scala new file mode 100644 index 000000000000..d33c520d1b5d --- /dev/null +++ b/test/files/pos/t8844.scala @@ -0,0 +1,4 @@ +object Example { + type S[A] = String + def foo(s: S[_]): String = s +} From e11fe9be4a6e7af42aa43b41747ee8007298726f Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Tue, 29 Jul 2014 15:25:00 +0200 Subject: [PATCH 548/826] spec: use the yaml title as the HTML title --- spec/_layouts/default.yml | 4 ++-- spec/_layouts/toc.yml | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/spec/_layouts/default.yml b/spec/_layouts/default.yml index d3296c6f5dba..c01e34d83ada 100644 --- a/spec/_layouts/default.yml +++ b/spec/_layouts/default.yml @@ -25,7 +25,7 @@ - + {{ page.title }} @@ -33,4 +33,4 @@ {{ content }} - \ No newline at end of file + diff --git a/spec/_layouts/toc.yml b/spec/_layouts/toc.yml index d77ea62a19f1..85e1e6bc5c3f 100644 --- a/spec/_layouts/toc.yml +++ b/spec/_layouts/toc.yml @@ -4,7 +4,7 @@ - + {{ page.title }} @@ -12,4 +12,4 @@ {{ content }} - \ No newline at end of file + From 6e1916212e10e2797867ec2b38d71b004f7bcb62 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Mon, 15 Sep 2014 08:46:25 +0200 Subject: [PATCH 549/826] spec: add syntax highlighting for scala code with highlight.js This adds syntax highlighting for all code scala blocks. Highlighting is done after MathJax is done rendering so that latex can be used in code blocks (and it currently *is* used). Sadly Scala isn't common enough to be bundled in the highlight.min.js available from CDNs, so we commit a local version of version 8.2 with only scala bundled in it. The only other language used (ebnf) isn't supported by highlight.js. --- spec/_layouts/default.yml | 17 +++++++++++++++++ spec/public/highlight/LICENSE | 24 ++++++++++++++++++++++++ spec/public/highlight/highlight.pack.js | 1 + 3 files changed, 42 insertions(+) create mode 100644 spec/public/highlight/LICENSE create mode 100644 spec/public/highlight/highlight.pack.js diff --git a/spec/_layouts/default.yml b/spec/_layouts/default.yml index c01e34d83ada..f78232f461e8 100644 --- a/spec/_layouts/default.yml +++ b/spec/_layouts/default.yml @@ -13,15 +13,32 @@ + + diff --git a/spec/public/highlight/LICENSE b/spec/public/highlight/LICENSE new file mode 100644 index 000000000000..422deb7350fe --- /dev/null +++ b/spec/public/highlight/LICENSE @@ -0,0 +1,24 @@ +Copyright (c) 2006, Ivan Sagalaev +All rights reserved. +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of highlight.js nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/spec/public/highlight/highlight.pack.js b/spec/public/highlight/highlight.pack.js new file mode 100644 index 000000000000..bfeca09abb51 --- /dev/null +++ b/spec/public/highlight/highlight.pack.js @@ -0,0 +1 @@ +var hljs=new function(){function j(v){return v.replace(/&/gm,"&").replace(//gm,">")}function t(v){return v.nodeName.toLowerCase()}function h(w,x){var v=w&&w.exec(x);return v&&v.index==0}function r(w){var v=(w.className+" "+(w.parentNode?w.parentNode.className:"")).split(/\s+/);v=v.map(function(x){return x.replace(/^lang(uage)?-/,"")});return v.filter(function(x){return i(x)||/no(-?)highlight/.test(x)})[0]}function o(x,y){var v={};for(var w in x){v[w]=x[w]}if(y){for(var w in y){v[w]=y[w]}}return v}function u(x){var v=[];(function w(y,z){for(var A=y.firstChild;A;A=A.nextSibling){if(A.nodeType==3){z+=A.nodeValue.length}else{if(A.nodeType==1){v.push({event:"start",offset:z,node:A});z=w(A,z);if(!t(A).match(/br|hr|img|input/)){v.push({event:"stop",offset:z,node:A})}}}}return z})(x,0);return v}function q(w,y,C){var x=0;var F="";var z=[];function B(){if(!w.length||!y.length){return w.length?w:y}if(w[0].offset!=y[0].offset){return(w[0].offset"}function E(G){F+=""}function v(G){(G.event=="start"?A:E)(G.node)}while(w.length||y.length){var D=B();F+=j(C.substr(x,D[0].offset-x));x=D[0].offset;if(D==w){z.reverse().forEach(E);do{v(D.splice(0,1)[0]);D=B()}while(D==w&&D.length&&D[0].offset==x);z.reverse().forEach(A)}else{if(D[0].event=="start"){z.push(D[0].node)}else{z.pop()}v(D.splice(0,1)[0])}}return F+j(C.substr(x))}function m(y){function v(z){return(z&&z.source)||z}function w(A,z){return RegExp(v(A),"m"+(y.cI?"i":"")+(z?"g":""))}function x(D,C){if(D.compiled){return}D.compiled=true;D.k=D.k||D.bK;if(D.k){var z={};var E=function(G,F){if(y.cI){F=F.toLowerCase()}F.split(" ").forEach(function(H){var I=H.split("|");z[I[0]]=[G,I[1]?Number(I[1]):1]})};if(typeof D.k=="string"){E("keyword",D.k)}else{Object.keys(D.k).forEach(function(F){E(F,D.k[F])})}D.k=z}D.lR=w(D.l||/\b[A-Za-z0-9_]+\b/,true);if(C){if(D.bK){D.b="\\b("+D.bK.split(" ").join("|")+")\\b"}if(!D.b){D.b=/\B|\b/}D.bR=w(D.b);if(!D.e&&!D.eW){D.e=/\B|\b/}if(D.e){D.eR=w(D.e)}D.tE=v(D.e)||"";if(D.eW&&C.tE){D.tE+=(D.e?"|":"")+C.tE}}if(D.i){D.iR=w(D.i)}if(D.r===undefined){D.r=1}if(!D.c){D.c=[]}var B=[];D.c.forEach(function(F){if(F.v){F.v.forEach(function(G){B.push(o(F,G))})}else{B.push(F=="self"?D:F)}});D.c=B;D.c.forEach(function(F){x(F,D)});if(D.starts){x(D.starts,C)}var A=D.c.map(function(F){return F.bK?"\\.?("+F.b+")\\.?":F.b}).concat([D.tE,D.i]).map(v).filter(Boolean);D.t=A.length?w(A.join("|"),true):{exec:function(F){return null}}}x(y)}function c(T,L,J,R){function v(V,W){for(var U=0;U";V+=aa+'">';return V+Y+Z}function N(){if(!I.k){return j(C)}var U="";var X=0;I.lR.lastIndex=0;var V=I.lR.exec(C);while(V){U+=j(C.substr(X,V.index-X));var W=E(I,V);if(W){H+=W[1];U+=w(W[0],j(V[0]))}else{U+=j(V[0])}X=I.lR.lastIndex;V=I.lR.exec(C)}return U+j(C.substr(X))}function F(){if(I.sL&&!f[I.sL]){return j(C)}var U=I.sL?c(I.sL,C,true,S):e(C);if(I.r>0){H+=U.r}if(I.subLanguageMode=="continuous"){S=U.top}return w(U.language,U.value,false,true)}function Q(){return I.sL!==undefined?F():N()}function P(W,V){var U=W.cN?w(W.cN,"",true):"";if(W.rB){D+=U;C=""}else{if(W.eB){D+=j(V)+U;C=""}else{D+=U;C=V}}I=Object.create(W,{parent:{value:I}})}function G(U,Y){C+=U;if(Y===undefined){D+=Q();return 0}var W=v(Y,I);if(W){D+=Q();P(W,Y);return W.rB?0:Y.length}var X=z(I,Y);if(X){var V=I;if(!(V.rE||V.eE)){C+=Y}D+=Q();do{if(I.cN){D+=""}H+=I.r;I=I.parent}while(I!=X.parent);if(V.eE){D+=j(Y)}C="";if(X.starts){P(X.starts,"")}return V.rE?0:Y.length}if(A(Y,I)){throw new Error('Illegal lexeme "'+Y+'" for mode "'+(I.cN||"")+'"')}C+=Y;return Y.length||1}var M=i(T);if(!M){throw new Error('Unknown language: "'+T+'"')}m(M);var I=R||M;var S;var D="";for(var K=I;K!=M;K=K.parent){if(K.cN){D=w(K.cN,"",true)+D}}var C="";var H=0;try{var B,y,x=0;while(true){I.t.lastIndex=x;B=I.t.exec(L);if(!B){break}y=G(L.substr(x,B.index-x),B[0]);x=B.index+y}G(L.substr(x));for(var K=I;K.parent;K=K.parent){if(K.cN){D+=""}}return{r:H,value:D,language:T,top:I}}catch(O){if(O.message.indexOf("Illegal")!=-1){return{r:0,value:j(L)}}else{throw O}}}function e(y,x){x=x||b.languages||Object.keys(f);var v={r:0,value:j(y)};var w=v;x.forEach(function(z){if(!i(z)){return}var A=c(z,y,false);A.language=z;if(A.r>w.r){w=A}if(A.r>v.r){w=v;v=A}});if(w.language){v.second_best=w}return v}function g(v){if(b.tabReplace){v=v.replace(/^((<[^>]+>|\t)+)/gm,function(w,z,y,x){return z.replace(/\t/g,b.tabReplace)})}if(b.useBR){v=v.replace(/\n/g,"
        ")}return v}function p(A){var B=r(A);if(/no(-?)highlight/.test(B)){return}var y;if(b.useBR){y=document.createElementNS("http://www.w3.org/1999/xhtml","div");y.innerHTML=A.innerHTML.replace(/\n/g,"").replace(//g,"\n")}else{y=A}var z=y.textContent;var v=B?c(B,z,true):e(z);var x=u(y);if(x.length){var w=document.createElementNS("http://www.w3.org/1999/xhtml","div");w.innerHTML=v.value;v.value=q(x,u(w),z)}v.value=g(v.value);A.innerHTML=v.value;A.className+=" hljs "+(!B&&v.language||"");A.result={language:v.language,re:v.r};if(v.second_best){A.second_best={language:v.second_best.language,re:v.second_best.r}}}var b={classPrefix:"hljs-",tabReplace:null,useBR:false,languages:undefined};function s(v){b=o(b,v)}function l(){if(l.called){return}l.called=true;var v=document.querySelectorAll("pre code");Array.prototype.forEach.call(v,p)}function a(){addEventListener("DOMContentLoaded",l,false);addEventListener("load",l,false)}var f={};var n={};function d(v,x){var w=f[v]=x(this);if(w.aliases){w.aliases.forEach(function(y){n[y]=v})}}function k(){return Object.keys(f)}function i(v){return f[v]||f[n[v]]}this.highlight=c;this.highlightAuto=e;this.fixMarkup=g;this.highlightBlock=p;this.configure=s;this.initHighlighting=l;this.initHighlightingOnLoad=a;this.registerLanguage=d;this.listLanguages=k;this.getLanguage=i;this.inherit=o;this.IR="[a-zA-Z][a-zA-Z0-9_]*";this.UIR="[a-zA-Z_][a-zA-Z0-9_]*";this.NR="\\b\\d+(\\.\\d+)?";this.CNR="(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)";this.BNR="\\b(0b[01]+)";this.RSR="!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~";this.BE={b:"\\\\[\\s\\S]",r:0};this.ASM={cN:"string",b:"'",e:"'",i:"\\n",c:[this.BE]};this.QSM={cN:"string",b:'"',e:'"',i:"\\n",c:[this.BE]};this.PWM={b:/\b(a|an|the|are|I|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such)\b/};this.CLCM={cN:"comment",b:"//",e:"$",c:[this.PWM]};this.CBCM={cN:"comment",b:"/\\*",e:"\\*/",c:[this.PWM]};this.HCM={cN:"comment",b:"#",e:"$",c:[this.PWM]};this.NM={cN:"number",b:this.NR,r:0};this.CNM={cN:"number",b:this.CNR,r:0};this.BNM={cN:"number",b:this.BNR,r:0};this.CSSNM={cN:"number",b:this.NR+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",r:0};this.RM={cN:"regexp",b:/\//,e:/\/[gim]*/,i:/\n/,c:[this.BE,{b:/\[/,e:/\]/,r:0,c:[this.BE]}]};this.TM={cN:"title",b:this.IR,r:0};this.UTM={cN:"title",b:this.UIR,r:0}}();hljs.registerLanguage("scala",function(d){var b={cN:"annotation",b:"@[A-Za-z]+"};var c={cN:"string",b:'u?r?"""',e:'"""',r:10};var a={cN:"symbol",b:"'\\w[\\w\\d_]*(?!')"};var e={cN:"type",b:"\\b[A-Z][A-Za-z0-9_]*",r:0};var h={cN:"title",b:/[^0-9\n\t "'(),.`{}\[\]:;][^\n\t "'(),.`{}\[\]:;]+|[^0-9\n\t "'(),.`{}\[\]:;=]/,r:0};var i={cN:"class",bK:"class object trait type",e:/[:={\[(\n;]/,c:[{cN:"keyword",bK:"extends with",r:10},h]};var g={cN:"function",bK:"def val",e:/[:={\[(\n;]/,c:[h]};var f={cN:"javadoc",b:"/\\*\\*",e:"\\*/",c:[{cN:"javadoctag",b:"@[A-Za-z]+"}],r:10};return{k:{literal:"true false null",keyword:"type yield lazy override def with val var sealed abstract private trait object if forSome for while throw finally protected extends import final return else break new catch super class case package default try this match continue throws implicit"},c:[d.CLCM,d.CBCM,c,d.QSM,a,e,g,i,d.CNM,b]}}); \ No newline at end of file From bca19f35103c4ff1205e1c8054eb3f803217a18b Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Mon, 15 Sep 2014 12:02:12 +0200 Subject: [PATCH 550/826] spec: fix latex formatting all over the place Two things worth mentioning: - `\em` and `emph` are not supported by MathJax, - and things like `\mathcal{C}_0` require escaping the `_`, otherwise markdown sees it as the beginning of `_some string_`. It doesn't happen without the closing bracket in front, e.g. in `b_0`. --- spec/01-lexical-syntax.md | 4 +- spec/03-types.md | 28 ++++----- spec/04-basic-declarations-and-definitions.md | 20 +++--- spec/05-classes-and-objects.md | 21 ++++--- spec/06-expressions.md | 32 +++++----- spec/07-implicit-parameters-and-views.md | 12 ++-- spec/08-pattern-matching.md | 62 ++++++++++--------- spec/10-xml-expressions-and-patterns.md | 24 +++---- spec/12-the-scala-standard-library.md | 2 +- 9 files changed, 104 insertions(+), 101 deletions(-) diff --git a/spec/01-lexical-syntax.md b/spec/01-lexical-syntax.md index 6c8712cda2f7..ef1f2bf053a4 100644 --- a/spec/01-lexical-syntax.md +++ b/spec/01-lexical-syntax.md @@ -429,7 +429,7 @@ by an [escape sequence](#escape-sequences). Note that `'\u000A'` is _not_ a valid character literal because Unicode conversion is done before literal parsing and the Unicode -character \\u000A (line feed) is not a printable +character `\u000A` (line feed) is not a printable character. One can use instead the escape sequence `'\n'` or the octal escape `'\12'` ([see here](#escape-sequences)). @@ -528,7 +528,7 @@ The following escape sequences are recognized in character and string literals. A character with Unicode between 0 and 255 may also be represented by -an octal escape, i.e. a backslash ‘\’ followed by a +an octal escape, i.e. a backslash `'\'` followed by a sequence of up to three octal characters. It is a compile time error if a backslash character in a character or diff --git a/spec/03-types.md b/spec/03-types.md index 4a02c7a8c1f3..29e6426530a9 100644 --- a/spec/03-types.md +++ b/spec/03-types.md @@ -231,7 +231,7 @@ SimpleType ::= ‘(’ Types ‘)’ ``` A tuple type $(T_1 , \ldots , T_n)$ is an alias for the -class `scala.Tuple$_n$[$T_1$, … , $T_n$]`, where $n \geq 2$. +class `scala.Tuple$n$[$T_1$, … , $T_n$]`, where $n \geq 2$. Tuple classes are case classes whose fields can be accessed using selectors `_1` , … , `_n`. Their functionality is @@ -241,12 +241,12 @@ standard Scala library (they might also add other methods and implement other traits). ```scala -case class Tuple$n$[+T1, … , +$T_n$](_1: T1, … , _n: $T_n$) -extends Product_n[T1, … , $T_n$] +case class Tuple$n$[+$T_1$, … , +$T_n$](_1: $T_1$, … , _n: $T_n$) +extends Product_n[$T_1$, … , $T_n$] -trait Product_n[+T1, … , +$T_n$] { +trait Product_n[+$T_1$, … , +$T_n$] { override def productArity = $n$ - def _1: T1 + def _1: $T_1$ … def _n: $T_n$ } @@ -362,7 +362,7 @@ operators are left-associative. In a sequence of consecutive type infix operations $t_0 \, \mathit{op} \, t_1 \, \mathit{op_2} \, \ldots \, \mathit{op_n} \, t_n$, -all operators $\mathit{op}_1 , \ldots , \mathit{op}_n$ must have the same +all operators $\mathit{op}\_1 , \ldots , \mathit{op}\_n$ must have the same associativity. If they are all left-associative, the sequence is interpreted as $(\ldots (t_0 \mathit{op_1} t_1) \mathit{op_2} \ldots) \mathit{op_n} t_n$, @@ -420,10 +420,10 @@ where $Q$ is a sequence of [type declarations](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases). Let -$t_1[\mathit{tps}_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}_n] >: L_n <: U_n$ -be the types declared in $Q$ (any of the +$t_1[\mathit{tps}\_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}\_n] >: L_n <: U_n$ +be the types declared in $Q$ (any of the type parameter sections `[ $\mathit{tps}_i$ ]` might be missing). -The scope of each type $t_i$ includes the type $T$ and the existential clause +The scope of each type $t_i$ includes the type $T$ and the existential clause $Q$. The type variables $t_i$ are said to be _bound_ in the type `$T$ forSome { $Q$ }`. @@ -438,7 +438,7 @@ is the union of the set of values of all its type instances. A _skolemization_ of `$T$ forSome { $Q$ }` is a type instance $\sigma T$, where $\sigma$ is the substitution -$[t'_1/t_1 , \ldots , t'_n/t_n]$ and each $t'_i$ is a fresh abstract type +$[t_1'/t_1 , \ldots , t_n'/t_n]$ and each $t_i'$ is a fresh abstract type with lower bound $\sigma L_i$ and upper bound $\sigma U_i$. #### Simplification Rules @@ -579,8 +579,8 @@ represents named methods that take arguments named $p_1 , \ldots , p_n$ of types $T_1 , \ldots , T_n$ and that return a result of type $U$. -Method types associate to the right: $(\mathit{Ps}_1)(\mathit{Ps}_2)U$ is -treated as $(\mathit{Ps}_1)((\mathit{Ps}_2)U)$. +Method types associate to the right: $(\mathit{Ps}\_1)(\mathit{Ps}\_2)U$ is +treated as $(\mathit{Ps}\_1)((\mathit{Ps}\_2)U)$. A special case are types of methods without any parameters. They are written here `=> T`. Parameterless methods name expressions @@ -634,7 +634,7 @@ produce the typings ```scala empty : [A >: Nothing <: Any] List[A] -union : [A >: Nothing <: Comparable[A]] (x: Set[A], xs: Set[A]) Set[A] . +union : [A >: Nothing <: Comparable[A]] (x: Set[A], xs: Set[A]) Set[A] ``` ### Type Constructors @@ -893,7 +893,7 @@ transitive relation that satisfies the following conditions. - Type constructors $T$ and $T'$ follow a similar discipline. We characterize $T$ and $T'$ by their type parameter clauses $[a_1 , \ldots , a_n]$ and - $[a'_1 , \ldots , a'_n ]$, where an $a_i$ or $a'_i$ may include a variance + $[a_1' , \ldots , a_n']$, where an $a_i$ or $a_i'$ may include a variance annotation, a higher-order type parameter clause, and bounds. Then, $T$ conforms to $T'$ if any list $[t_1 , \ldots , t_n]$ -- with declared variances, bounds and higher-order type parameter clauses -- of valid type diff --git a/spec/04-basic-declarations-and-definitions.md b/spec/04-basic-declarations-and-definitions.md index ab1f98ea0793..358a4765ff3e 100644 --- a/spec/04-basic-declarations-and-definitions.md +++ b/spec/04-basic-declarations-and-definitions.md @@ -111,7 +111,7 @@ ids ::= id {‘,’ id} ``` A value declaration `val $x$: $T$` introduces $x$ as a name of a value of -type $T$. +type $T$. A value definition `val $x$: $T$ = $e$` defines $x$ as a name of the value that results from the evaluation of $e$. @@ -152,7 +152,7 @@ $\ldots$ val $x_n$ = $\$ x$._n . ``` -Here, $\$ x$ is a fresh name. +Here, $\$ x$ is a fresh name. 2. If $p$ has a unique bound variable $x$: @@ -339,13 +339,13 @@ A _type alias_ `type $t$ = $T$` defines $t$ to be an alias name for the type $T$. The left hand side of a type alias may have a type parameter clause, e.g. `type $t$[$\mathit{tps}\,$] = $T$`. The scope of a type parameter extends over the right hand side $T$ and the -type parameter clause $\mathit{tps}$ itself. +type parameter clause $\mathit{tps}$ itself. The scope rules for [definitions](#basic-declarations-and-definitions) and [type parameters](#function-declarations-and-definitions) make it possible that a type name appears in its own bound or in its right-hand side. However, it is a static error if -a type alias refers recursively to the defined type constructor itself. +a type alias refers recursively to the defined type constructor itself. That is, the type $T$ in a type alias `type $t$[$\mathit{tps}\,$] = $T$` may not refer directly or indirectly to the name $t$. It is also an error if an abstract type is directly or indirectly its own upper or lower bound. @@ -436,9 +436,9 @@ TODO: this is a pretty awkward description of scoping and distinctness of binder The names of all type parameters must be pairwise different in their enclosing type parameter clause. The scope of a type parameter includes in each case the whole type parameter clause. Therefore it is possible that a type parameter appears as part of its own bounds or the bounds of other type parameters in the same clause. However, a type parameter may not be bounded directly or indirectly by itself. -A type constructor parameter adds a nested type parameter clause to the type parameter. The most general form of a type constructor parameter is `$@a_1\ldots@a_n$ $\pm$ $t[\mathit{tps}\,]$ >: $L$ <: $U$`. +A type constructor parameter adds a nested type parameter clause to the type parameter. The most general form of a type constructor parameter is `$@a_1\ldots@a_n$ $\pm$ $t[\mathit{tps}\,]$ >: $L$ <: $U$`. -The above scoping restrictions are generalized to the case of nested type parameter clauses, which declare higher-order type parameters. Higher-order type parameters (the type parameters of a type parameter $t$) are only visible in their immediately surrounding parameter clause (possibly including clauses at a deeper nesting level) and in the bounds of $t$. Therefore, their names must only be pairwise different from the names of other visible parameters. Since the names of higher-order type parameters are thus often irrelevant, they may be denoted with a ‘_’, which is nowhere visible. +The above scoping restrictions are generalized to the case of nested type parameter clauses, which declare higher-order type parameters. Higher-order type parameters (the type parameters of a type parameter $t$) are only visible in their immediately surrounding parameter clause (possibly including clauses at a deeper nesting level) and in the bounds of $t$. Therefore, their names must only be pairwise different from the names of other visible parameters. Since the names of higher-order type parameters are thus often irrelevant, they may be denoted with a `‘_’`, which is nowhere visible. ###### Example Here are some well-formed type parameter clauses: @@ -498,7 +498,7 @@ changes at the following constructs. - The variance position of a type parameter is the opposite of the variance position of the enclosing type parameter clause. - The variance position of the lower bound of a type declaration or type parameter - is the opposite of the variance position of the type declaration or parameter. + is the opposite of the variance position of the type declaration or parameter. - The type of a mutable variable is always in invariant position. - The right-hand side of a type alias is always in invariant position. - The prefix $S$ of a type selection `$S$#$T$` is always in invariant position. @@ -628,7 +628,7 @@ A type parameter clause $\mathit{tps}$ consists of one or more [type declarations](#type-declarations-and-type-aliases), which introduce type parameters, possibly with bounds. The scope of a type parameter includes the whole signature, including any of the type parameter bounds as -well as the function body, if it is present. +well as the function body, if it is present. A value parameter clause $\mathit{ps}$ consists of zero or more formal parameter bindings such as `$x$: $T$` or `$x: T = e$`, which bind value @@ -708,7 +708,7 @@ ParamType ::= Type ‘*’ ``` The last value parameter of a parameter section may be suffixed by -“*”, e.g. `(..., $x$:$T$*)`. The type of such a +`'*'`, e.g. `(..., $x$:$T$*)`. The type of such a _repeated_ parameter inside the method is then the sequence type `scala.Seq[$T$]`. Methods with repeated parameters `$T$*` take a variable number of arguments of type $T$. @@ -878,7 +878,7 @@ The most general form of an import expression is a list of _import selectors_ { $x_1$ => $y_1 , \ldots , x_n$ => $y_n$, _ } ``` -for $n \geq 0$, where the final wildcard ‘_’ may be absent. It +for $n \geq 0$, where the final wildcard `‘_’` may be absent. It makes available each importable member `$p$.$x_i$` under the unqualified name $y_i$. I.e. every import selector `$x_i$ => $y_i$` renames `$p$.$x_i$` to diff --git a/spec/05-classes-and-objects.md b/spec/05-classes-and-objects.md index 70fa3e0272f6..429f0b75bccd 100644 --- a/spec/05-classes-and-objects.md +++ b/spec/05-classes-and-objects.md @@ -339,7 +339,8 @@ $M'$: - If $M$ is labeled `private[$C$]` for some enclosing class or package $C$, then $M'$ must be labeled `private[$C'$]` for some class or package $C'$ where $C'$ equals $C$ or $C'$ is contained in $C$. - + + - If $M$ is labeled `protected`, then $M'$ must also be labeled `protected`. - If $M'$ is not an abstract member, then $M$ must be labeled `override`. @@ -699,7 +700,7 @@ ClassTemplateOpt ::= `extends' ClassTemplate | [[`extends'] TemplateBody] The most general form of class definition is ```scala -class $c$[$\mathit{tps}\,$] $as$ $m$($\mathit{ps}_1$)$\ldots$($\mathit{ps}_n$) extends $t$ $\gap(n \geq 0)$. +class $c$[$\mathit{tps}\,$] $as$ $m$($\mathit{ps}_1$)$\ldots$($\mathit{ps}_n$) extends $t$ $\quad(n \geq 0)$. ``` Here, @@ -719,7 +720,7 @@ Here, - $m$ is an [access modifier](#modifiers) such as `private` or `protected`, possibly with a qualification. If such an access modifier is given it applies to the primary constructor of the class. - - $(\mathit{ps}_1)\ldots(\mathit{ps}_n)$ are formal value parameter clauses for + - $(\mathit{ps}\_1)\ldots(\mathit{ps}\_n)$ are formal value parameter clauses for the _primary constructor_ of the class. The scope of a formal value parameter includes all subsequent parameter sections and the template $t$. However, a formal value parameter may not form part of the types of any of the parent classes or members of the class template $t$. @@ -885,10 +886,10 @@ object $c$ { Here, $\mathit{Ts}$ stands for the vector of types defined in the type parameter section $\mathit{tps}$, -each $\mathit{xs}_i$ denotes the parameter names of the parameter -section $\mathit{ps}_i$, and -$\mathit{xs}_{11}, \ldots , \mathit{xs}_{1k}$ denote the names of all parameters -in the first parameter section $\mathit{xs}_1$. +each $\mathit{xs}\_i$ denotes the parameter names of the parameter +section $\mathit{ps}\_i$, and +$\mathit{xs}\_{11}, \ldots , \mathit{xs}\_{1k}$ denote the names of all parameters +in the first parameter section $\mathit{xs}\_1$. If a type parameter section is missing in the class, it is also missing in the `apply` and `unapply` methods. @@ -919,9 +920,9 @@ def copy[$\mathit{tps}\,$]($\mathit{ps}'_1\,$)$\ldots$($\mathit{ps}'_n$): $c$[$\ ``` Again, `$\mathit{Ts}$` stands for the vector of types defined in the type parameter section `$\mathit{tps}$` -and each `$\xs_i$` denotes the parameter names of the parameter section `$\ps'_i$`. The value -parameters `$\ps'_{1,j}$` of first parameter list have the form `$x_{1,j}$:$T_{1,j}$=this.$x_{1,j}$`, -the other parameters `$\ps'_{i,j}$` of the `copy` method are defined as `$x_{i,j}$:$T_{i,j}$`. +and each `$xs_i$` denotes the parameter names of the parameter section `$ps'_i$`. The value +parameters `$ps'_{1,j}$` of first parameter list have the form `$x_{1,j}$:$T_{1,j}$=this.$x_{1,j}$`, +the other parameters `$ps'_{i,j}$` of the `copy` method are defined as `$x_{i,j}$:$T_{i,j}$`. In all cases `$x_{i,j}$` and `$T_{i,j}$` refer to the name and type of the corresponding class parameter `$\mathit{ps}_{i,j}$`. diff --git a/spec/06-expressions.md b/spec/06-expressions.md index b2144aac6d83..7e0a5facf135 100644 --- a/spec/06-expressions.md +++ b/spec/06-expressions.md @@ -62,12 +62,12 @@ $T$, then the type of the expression is assumed instead to be a [skolemization](03-types.html#existential-types) of $T$. Skolemization is reversed by type packing. Assume an expression $e$ of -type $T$ and let $t_1[\mathit{tps}_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}_n] >: L_n <: U_n$ be +type $T$ and let $t_1[\mathit{tps}\_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}\_n] >: L_n <: U_n$ be all the type variables created by skolemization of some part of $e$ which are free in $T$. Then the _packed type_ of $e$ is ```scala -$T$ forSome { type $t_1[\mathit{tps}_1] >: L_1 <: U_1$; $\ldots$; type $t_n[\mathit{tps}_n] >: L_n <: U_n$ }. +$T$ forSome { type $t_1[\mathit{tps}\_1] >: L_1 <: U_1$; $\ldots$; type $t_n[\mathit{tps}\_n] >: L_n <: U_n$ }. ``` @@ -269,7 +269,7 @@ it has the form $x_i=e'_i$ and $x_i$ is one of the parameter names $p_1 , \ldots , p_n$. The function $f$ is applicable if all of the following conditions hold: -- For every named argument $x_i=e'_i$ the type $S_i$ +- For every named argument $x_i=e_i'$ the type $S_i$ is compatible with the parameter type $T_j$ whose name $p_j$ matches $x_i$. - For every positional argument $e_i$ the type $S_i$ is compatible with $T_i$. @@ -388,7 +388,7 @@ the form } ``` -where every argument in $(\mathit{args}_1) , \ldots , (\mathit{args}_l)$ is a reference to +where every argument in $(\mathit{args}\_1) , \ldots , (\mathit{args}\_l)$ is a reference to one of the values $x_1 , \ldots , x_k$. To integrate the current application into the block, first a value definition using a fresh name $y_i$ is created for every argument in $e_1 , \ldots , e_m$, which is initialised to $e_i$ for @@ -700,18 +700,18 @@ parts of an expression as follows. expression, then operators with higher precedence bind more closely than operators with lower precedence. - If there are consecutive infix - operations $e_0; \mathit{op}_1; e_1; \mathit{op}_2 \ldots \mathit{op}_n; e_n$ - with operators $\mathit{op}_1 , \ldots , \mathit{op}_n$ of the same precedence, + operations $e_0; \mathit{op}\_1; e_1; \mathit{op}\_2 \ldots \mathit{op}\_n; e_n$ + with operators $\mathit{op}\_1 , \ldots , \mathit{op}\_n$ of the same precedence, then all these operators must have the same associativity. If all operators are left-associative, the sequence is interpreted as - $(\ldots(e_0;\mathit{op}_1;e_1);\mathit{op}_2\ldots);\mathit{op}_n;e_n$. + $(\ldots(e_0;\mathit{op}\_1;e_1);\mathit{op}\_2\ldots);\mathit{op}\_n;e_n$. Otherwise, if all operators are right-associative, the sequence is interpreted as - $e_0;\mathit{op}_1;(e_1;\mathit{op}_2;(\ldots \mathit{op}_n;e_n)\ldots)$. + $e_0;\mathit{op}\_1;(e_1;\mathit{op}\_2;(\ldots \mathit{op}\_n;e_n)\ldots)$. - Postfix operators always have lower precedence than infix - operators. E.g. $e_1;\mathit{op}_1;e_2;\mathit{op}_2$ is always equivalent to - $(e_1;\mathit{op}_1;e_2);\mathit{op}_2$. + operators. E.g. $e_1;\mathit{op}\_1;e_2;\mathit{op}\_2$ is always equivalent to + $(e_1;\mathit{op}\_1;e_2);\mathit{op}\_2$. The right-hand operand of a left-associative operator may consist of several arguments enclosed in parentheses, e.g. $e;\mathit{op};(e_1,\ldots,e_n)$. @@ -817,12 +817,12 @@ the invocation of an `update` function defined by $f$. ###### Example Here are some assignment expressions and their equivalent expansions. --------------------------- --------------------- -`x.f = e` x.f_=(e) -`x.f() = e` x.f.update(e) -`x.f(i) = e` x.f.update(i, e) -`x.f(i, j) = e` x.f.update(i, j, e) --------------------------- --------------------- +| assignment | expansion | +|--------------------------|----------------------| +|`x.f = e` | `x.f_=(e)` | +|`x.f() = e` | `x.f.update(e)` | +|`x.f(i) = e` | `x.f.update(i, e)` | +|`x.f(i, j) = e` | `x.f.update(i, j, e)`| ### Example diff --git a/spec/07-implicit-parameters-and-views.md b/spec/07-implicit-parameters-and-views.md index 1a4d70409c0c..e07adc9e8209 100644 --- a/spec/07-implicit-parameters-and-views.md +++ b/spec/07-implicit-parameters-and-views.md @@ -203,14 +203,14 @@ the type: - For a singleton type, $\mathit{ttcs}(p.type) ~=~ \mathit{ttcs}(T)$, provided $p$ has type $T$; - For a compound type, `$\mathit{ttcs}(T_1$ with $\ldots$ with $T_n)$` $~=~ \mathit{ttcs}(T_1) \cup \ldots \cup \mathit{ttcs}(T_n)$. -The _complexity_ $\mathit{complexity}(T)$ of a core type is an integer which also depends on the form of +The _complexity_ $\operatorname{complexity}(T)$ of a core type is an integer which also depends on the form of the type: -- For a type designator, $\mathit{complexity}(p.c) ~=~ 1 + \mathit{complexity}(p)$ -- For a parameterized type, $\mathit{complexity}(p.c[\mathit{targs}]) ~=~ 1 + \Sigma \mathit{complexity}(\mathit{targs})$ -- For a singleton type denoting a package $p$, $\mathit{complexity}(p.type) ~=~ 0$ -- For any other singleton type, $\mathit{complexity}(p.type) ~=~ 1 + \mathit{complexity}(T)$, provided $p$ has type $T$; -- For a compound type, `$\mathit{complexity}(T_1$ with $\ldots$ with $T_n)$` $= \Sigma\mathit{complexity}(T_i)$ +- For a type designator, $\operatorname{complexity}(p.c) ~=~ 1 + \operatorname{complexity}(p)$ +- For a parameterized type, $\operatorname{complexity}(p.c[\mathit{targs}]) ~=~ 1 + \Sigma \operatorname{complexity}(\mathit{targs})$ +- For a singleton type denoting a package $p$, $\operatorname{complexity}(p.type) ~=~ 0$ +- For any other singleton type, $\operatorname{complexity}(p.type) ~=~ 1 + \operatorname{complexity}(T)$, provided $p$ has type $T$; +- For a compound type, `$\operatorname{complexity}(T_1$ with $\ldots$ with $T_n)$` $= \Sigma\operatorname{complexity}(T_i)$ ###### Example diff --git a/spec/08-pattern-matching.md b/spec/08-pattern-matching.md index 7b4d070181e7..6f71196b0db4 100644 --- a/spec/08-pattern-matching.md +++ b/spec/08-pattern-matching.md @@ -63,7 +63,7 @@ patterns. A variable pattern $x$ is a simple identifier which starts with a lower case letter. It matches any value, and binds the variable name to that value. The type of $x$ is the expected type of the pattern as -given from outside. A special case is the wild-card pattern $\_$ +given from outside. A special case is the wild-card pattern `_` which is treated as if it was a fresh variable on each occurrence. ### Typed Patterns @@ -100,7 +100,7 @@ and it binds the variable name to that value. ``` A literal pattern $L$ matches any value that is equal (in terms of -$==$) to the literal $L$. The type of $L$ must conform to the +`==`) to the literal $L$. The type of $L$ must conform to the expected type of the pattern. ### Stable Identifier Patterns @@ -346,7 +346,7 @@ A type pattern $T$ is of one of the following forms: the type patterns $T_i$. * A parameterized type pattern $T[a_1 , \ldots , a_n]$, where the $a_i$ - are type variable patterns or wildcards $\_$. + are type variable patterns or wildcards `_`. This type pattern matches all values which match $T$ for some arbitrary instantiation of the type variables and wildcards. The bounds or alias type of these type variable are determined as @@ -377,62 +377,64 @@ pattern. ### Type parameter inference for typed patterns. Assume a typed pattern $p: T'$. Let $T$ result from $T'$ where all wildcards in -$T'$ are renamed to fresh variable names. Let $a_1 , \ldots , a_n$ be +$T'$ are renamed to fresh variable names. Let $a_1 , \ldots , a_n$ be the type variables in $T$. These type variables are considered bound in the pattern. Let the expected type of the pattern be $\mathit{pt}$. Type parameter inference constructs first a set of subtype constraints over -the type variables $a_i$. The initial constraints set $\mathcal{C}_0$ reflects +the type variables $a_i$. The initial constraints set $\mathcal{C}\_0$ reflects just the bounds of these type variables. That is, assuming $T$ has bound type variables $a_1 , \ldots , a_n$ which correspond to class -type parameters $a'_1 , \ldots , a'_n$ with lower bounds $L_1, \ldots , L_n$ +type parameters $a_1' , \ldots , a_n'$ with lower bounds $L_1, \ldots , L_n$ and upper bounds $U_1 , \ldots , U_n$, $\mathcal{C}_0$ contains the constraints -| | | | | -|-------------|------|---------------|------------------------| -|$a_i$ | $<:$ | $\sigma U_i$ | $(i = 1, \ldots , n)$ | -|$\sigma L_i$ | $<:$ | $a_i$ | $(i = 1 , \ldots , n)$ | +$$ +\begin{cases} +a_i &<: \sigma U_i & \quad (i = 1, \ldots , n) \\\\ +\sigma L_i &<: a_i & \quad (i = 1, \ldots , n) +\end{cases} +$$ -where $\sigma$ is the substitution $[a'_1 := a_1 , \ldots , a'_n := -a_n]$. +where $\sigma$ is the substitution $[a_1' := a_1 , \ldots , a_n' :=a_n]$. The set $\mathcal{C}_0$ is then augmented by further subtype constraints. There are two cases. ###### Case 1 -If there exists a substitution $\sigma$ over the type variables $a_i , \ldots , a_n$ such that $\sigma T$ conforms to $\mathit{pt}$, one determines the weakest subtype constraints $\mathcal{C}_1$ over the type variables $a_1, \ldots , a_n$ such that $\mathcal{C}_0 \wedge \mathcal{C}_1$ implies that $T$ conforms to $\mathit{pt}$. +If there exists a substitution $\sigma$ over the type variables $a_i , \ldots , a_n$ such that $\sigma T$ conforms to $\mathit{pt}$, one determines the weakest subtype constraints +$\mathcal{C}\_1$ over the type variables $a_1, \ldots , a_n$ such that $\mathcal{C}\_0 \wedge \mathcal{C}_1$ implies that $T$ conforms to $\mathit{pt}$. ###### Case 2 Otherwise, if $T$ can not be made to conform to $\mathit{pt}$ by instantiating its type variables, one determines all type variables in $\mathit{pt}$ which are defined as type parameters of a method enclosing the pattern. Let the set of such type parameters be $b_1 , \ldots , -b_m$. Let $\mathcal{C}'_0$ be the subtype constraints reflecting the bounds of the +b_m$. Let $\mathcal{C}\_0'$ be the subtype constraints reflecting the bounds of the type variables $b_i$. If $T$ denotes an instance type of a final -class, let $\mathcal{C}_2$ be the weakest set of subtype constraints over the type +class, let $\mathcal{C}\_2$ be the weakest set of subtype constraints over the type variables $a_1 , \ldots , a_n$ and $b_1 , \ldots , b_m$ such that -$\mathcal{C}_0 \wedge \mathcal{C}'_0 \wedge \mathcal{C}_2$ implies that $T$ conforms to +$\mathcal{C}\_0 \wedge \mathcal{C}\_0' \wedge \mathcal{C}\_2$ implies that $T$ conforms to $\mathit{pt}$. If $T$ does not denote an instance type of a final class, -let $\mathcal{C}_2$ be the weakest set of subtype constraints over the type variables -$a_1 , \ldots , a_n$ and $b_1 , \ldots , b_m$ such that $\mathcal{C}_0 \wedge -\mathcal{C}'_0 \wedge \mathcal{C}_2$ implies that it is possible to construct a type +let $\mathcal{C}\_2$ be the weakest set of subtype constraints over the type variables +$a_1 , \ldots , a_n$ and $b_1 , \ldots , b_m$ such that $\mathcal{C}\_0 \wedge +\mathcal{C}\_0' \wedge \mathcal{C}\_2$ implies that it is possible to construct a type $T'$ which conforms to both $T$ and $\mathit{pt}$. It is a static error if -there is no satisfiable set of constraints $\mathcal{C}_2$ with this property. +there is no satisfiable set of constraints $\mathcal{C}\_2$ with this property. The final step consists in choosing type bounds for the type variables which imply the established constraint system. The process is different for the two cases above. ###### Case 1 -We take $a_i >: L_i <: U_i$ where each $L_i$ is minimal and each $U_i$ is maximal wrt $<:$ such that $a_i >: L_i <: U_i$ for $i = 1, \ldots, n$ implies $\mathcal{C}_0 \wedge \mathcal{C}_1$. +We take $a_i >: L_i <: U_i$ where each $L_i$ is minimal and each $U_i$ is maximal wrt $<:$ such that $a_i >: L_i <: U_i$ for $i = 1, \ldots, n$ implies $\mathcal{C}\_0 \wedge \mathcal{C}\_1$. ###### Case 2 -We take $a_i >: L_i <: U_i$ and $b_i >: L'_i <: U'_i$ where each $L_i$ -and $L'_j$ is minimal and each $U_i$ and $U'_j$ is maximal such that +We take $a_i >: L_i <: U_i$ and $b\_i >: L_i' <: U_i' $ where each $L_i$ +and $L_j'$ is minimal and each $U_i$ and $U_j'$ is maximal such that $a_i >: L_i <: U_i$ for $i = 1 , \ldots , n$ and -$b_j >: L'_j <: U'_j$ for $j = 1 , \ldots , m$ -implies $\mathcal{C}_0 \wedge \mathcal{C}'_0 \wedge \mathcal{C}_2$. +$b_j >: L_j' <: U_j'$ for $j = 1 , \ldots , m$ +implies $\mathcal{C}\_0 \wedge \mathcal{C}\_0' \wedge \mathcal{C}_2$. In both cases, local type inference is permitted to limit the complexity of inferred bounds. Minimality and maximality of types have @@ -552,16 +554,16 @@ $T$ by replacing every occurrence of a type parameter $a_i$ by \mbox{\sl undefined}. If this second step fails also, a compile-time error results. If the second step succeeds, let $T_p$ be the type of pattern $p$ seen as an expression. One then determines minimal bounds -$L'_1 , \ldots , L'_m$ and maximal bounds $U'_1 , \ldots , U'_m$ such -that for all $i$, $L_i <: L'_i$ and $U'_i <: U_i$ and the following +$L_11 , \ldots , L_m'$ and maximal bounds $U_1' , \ldots , U_m'$ such +that for all $i$, $L_i <: L_i'$ and $U_i' <: U_i$ and the following constraint system is satisfied: $$L_1 <: a_1 <: U_1\;\wedge\;\ldots\;\wedge\;L_m <: a_m <: U_m \ \Rightarrow\ T_p <: T$$ If no such bounds can be found, a compile time error results. If such bounds are found, the pattern matching clause starting with $p$ is -then typed under the assumption that each $a_i$ has lower bound $L'_i$ -instead of $L_i$ and has upper bound $U'_i$ instead of $U_i$. +then typed under the assumption that each $a_i$ has lower bound $L_i'$ +instead of $L_i$ and has upper bound $U_i'$ instead of $U_i$. The expected type of every block $b_i$ is the expected type of the whole pattern matching expression. The type of the pattern matching @@ -571,7 +573,7 @@ $b_i$. When applying a pattern matching expression to a selector value, patterns are tried in sequence until one is found which matches the -[selector value](#patterns). Say this case is `$case p_i \Rightarrow b_i$`. +[selector value](#patterns). Say this case is `case $p_i \Rightarrow b_i$`. The result of the whole expression is the result of evaluating $b_i$, where all pattern variables of $p_i$ are bound to the corresponding parts of the selector value. If no matching pattern diff --git a/spec/10-xml-expressions-and-patterns.md b/spec/10-xml-expressions-and-patterns.md index d8c45ecf85d0..8d4b45984432 100644 --- a/spec/10-xml-expressions-and-patterns.md +++ b/spec/10-xml-expressions-and-patterns.md @@ -37,10 +37,10 @@ Entity references are not resolved at runtime. Element ::= EmptyElemTag | STag Content ETag -EmptyElemTag ::= ‘<’ Name {S Attribute} [S] ‘/>’ +EmptyElemTag ::= ‘<’ Name {S Attribute} [S] ‘/>’ -STag ::= ‘<’ Name {S Attribute} [S] ‘>’ -ETag ::= ‘’ +STag ::= ‘<’ Name {S Attribute} [S] ‘>’ +ETag ::= ‘’ Content ::= [CharData] {Content1 [CharData]} Content1 ::= XmlContent | Reference @@ -68,7 +68,7 @@ character `\u0020`. This behavior can be changed to preserve all whitespace with a compiler option. ```ebnf -Attribute ::= Name Eq AttValue +Attribute ::= Name Eq AttValue AttValue ::= ‘"’ {CharQ | CharRef} ‘"’ | ‘'’ {CharA | CharRef} ‘'’ @@ -76,8 +76,8 @@ AttValue ::= ‘"’ {CharQ | CharRef} ‘"’ ScalaExpr ::= Block -CharData ::= { CharNoRef } $\mbox{\rm\em without}$ {CharNoRef}`{'CharB {CharNoRef} - $\mbox{\rm\em and without}$ {CharNoRef}`]]>'{CharNoRef} +CharData ::= { CharNoRef } $\textit{ without}$ {CharNoRef}`{'CharB {CharNoRef} + $\textit{ and without}$ {CharNoRef}`]]>'{CharNoRef} ``` @@ -90,17 +90,17 @@ Thus, `{{` represents the XML text `{` and does not introduce an embedded Scala ```ebnf BaseChar, Char, Comment, CombiningChar, Ideographic, NameChar, S, Reference - ::= $\mbox{\rm\em “as in W3C XML”}$ + ::= $\textit{“as in W3C XML”}$ -Char1 ::= Char $\mbox{\rm\em without}$ ‘<’ | ‘&’ -CharQ ::= Char1 $\mbox{\rm\em without}$ ‘"’ -CharA ::= Char1 $\mbox{\rm\em without}$ ‘'’ -CharB ::= Char1 $\mbox{\rm\em without}$ ‘{’ +Char1 ::= Char $\textit{ without}$ ‘<’ | ‘&’ +CharQ ::= Char1 $\textit{ without}$ ‘"’ +CharA ::= Char1 $\textit{ without}$ ‘'’ +CharB ::= Char1 $\textit{ without}$ ‘{’ Name ::= XNameStart {NameChar} XNameStart ::= ‘_’ | BaseChar | Ideographic - $\mbox{\rm\em (as in W3C XML, but without }$ ‘:’ + $\textit{ (as in W3C XML, but without }$ ‘:’$)$ ``` ## XML patterns diff --git a/spec/12-the-scala-standard-library.md b/spec/12-the-scala-standard-library.md index 9d4d69e52a06..7ccbe0c9bdc8 100644 --- a/spec/12-the-scala-standard-library.md +++ b/spec/12-the-scala-standard-library.md @@ -86,8 +86,8 @@ class AnyRef extends Any { def synchronized[T](body: => T): T // execute `body` in while locking `this`. } +``` -```scala The type test `$x$.isInstanceOf[$T$]` is equivalent to a typed pattern match From 3b0c71df60a41e13e47ec9ae8dbc606e1928aba8 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Mon, 15 Sep 2014 12:08:51 +0200 Subject: [PATCH 551/826] spec: remove trailing whitespace everywhere --- spec/01-lexical-syntax.md | 60 ++-- spec/02-identifiers-names-and-scopes.md | 11 +- spec/03-types.md | 281 ++++++++---------- spec/04-basic-declarations-and-definitions.md | 109 +++---- spec/05-classes-and-objects.md | 110 +++---- spec/06-expressions.md | 245 +++++++-------- spec/07-implicit-parameters-and-views.md | 47 ++- spec/08-pattern-matching.md | 62 ++-- spec/09-top-level-definitions.md | 14 +- spec/10-xml-expressions-and-patterns.md | 33 +- spec/11-user-defined-annotations.md | 5 +- spec/12-the-scala-standard-library.md | 129 ++++---- spec/13-syntax-summary.md | 36 +-- spec/14-references.md | 8 +- spec/README.md | 5 +- spec/index.md | 2 - 16 files changed, 497 insertions(+), 660 deletions(-) diff --git a/spec/01-lexical-syntax.md b/spec/01-lexical-syntax.md index ef1f2bf053a4..4bfef79ac5cd 100644 --- a/spec/01-lexical-syntax.md +++ b/spec/01-lexical-syntax.md @@ -11,7 +11,7 @@ Scala programs are written using the Unicode Basic Multilingual Plane presently supported. This chapter defines the two modes of Scala's lexical syntax, the Scala mode and the _XML mode_. If not otherwise mentioned, the following descriptions of Scala tokens refer -to _Scala mode_, and literal characters ‘c’ refer to the ASCII fragment +to _Scala mode_, and literal characters ‘c’ refer to the ASCII fragment `\u0000` – `\u007F`. In Scala mode, _Unicode escapes_ are replaced by the corresponding @@ -29,7 +29,7 @@ but I can't make it work nor can I imagine how this would make sense, so I removed it for now. --> -To construct tokens, characters are distinguished according to the following +To construct tokens, characters are distinguished according to the following classes (Unicode general category given in parentheses): 1. Whitespace characters. `\u0020 | \u0009 | \u000D | \u000A`. @@ -41,13 +41,13 @@ classes (Unicode general category given in parentheses): 1. Parentheses `‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’ `. 1. Delimiter characters ``‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’ ``. 1. Operator characters. These consist of all printable ASCII characters - `\u0020` - `\u007F` which are in none of the sets above, mathematical + `\u0020` - `\u007F` which are in none of the sets above, mathematical symbols (`Sm`) and other symbols (`So`). ## Identifiers ```ebnf -op ::= opchar {opchar} +op ::= opchar {opchar} varid ::= lower idrest plainid ::= upper idrest | varid @@ -61,14 +61,14 @@ There are three ways to form an identifier. First, an identifier can start with a letter which can be followed by an arbitrary sequence of letters and digits. This may be followed by underscore ‘_’ characters and another string composed of either letters and digits or -of operator characters. Second, an identifier can start with an operator +of operator characters. Second, an identifier can start with an operator character followed by an arbitrary sequence of operator characters. The preceding two forms are called _plain_ identifiers. Finally, an identifier may also be formed by an arbitrary string between back-quotes (host systems may impose some restrictions on which strings are legal for identifiers). The identifier then is composed of all characters excluding the backquotes themselves. - + As usual, a longest match rule applies. For instance, the string ```scala @@ -92,8 +92,8 @@ do else extends false final finally for forSome if implicit import lazy match new null object override package private protected -return sealed super this throw -trait try true type val +return sealed super this throw +trait try true type val var while with yield _ : = => <- <: <% >: # @ ``` @@ -115,7 +115,6 @@ For instance, the statement `Thread.yield()` is illegal, since `yield` is a reserved word in Scala. However, here's a work-around: `` Thread.`yield`() `` - ## Newline Characters ```ebnf @@ -134,7 +133,7 @@ The tokens that can terminate a statement are: literals, identifiers and the following delimiters and reserved words: ```scala -this null true false return type +this null true false return type _ ) ] } ``` @@ -142,8 +141,8 @@ The tokens that can begin a statement are all Scala tokens _except_ the following delimiters and reserved words: ```scala -catch else extends finally forSome match -with yield , . ; : = => <- <: <% +catch else extends finally forSome match +with yield , . ; : = => <- <: <% >: # [ ) ] } ``` @@ -169,7 +168,7 @@ Newlines are disabled in: 1. Any regions analyzed in [XML mode](#xml-mode). Note that the brace characters of `{...}` escapes in XML and -string literals are not tokens, +string literals are not tokens, and therefore do not enclose a region where newlines are enabled. @@ -189,14 +188,14 @@ Multiple newline tokens are accepted in the following places (note that a semicolon in place of the newline would be illegal in every one of these cases): -- between the condition of a +- between the condition of a [conditional expression](06-expressions.html#conditional-expressions) or [while loop](06-expressions.html#while-loop-expressions) and the next following expression, -- between the enumerators of a +- between the enumerators of a [for-comprehension](06-expressions.html#for-comprehensions-and-for-loops) and the next following expression, and -- after the initial `type` keyword in a +- after the initial `type` keyword in a [type definition or declaration](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases). A single new line token is accepted @@ -300,16 +299,15 @@ illegal). protected class Data { ... } ``` - ## Literals There are literals for integer numbers, floating point numbers, characters, booleans, symbols, strings. The syntax of these literals is in each case as in Java. - ```ebnf @@ -322,11 +320,10 @@ Literal ::= [‘-’] integerLiteral | ‘null’ ``` - ### Integer Literals ```ebnf -integerLiteral ::= (decimalNumeral | hexNumeral | octalNumeral) +integerLiteral ::= (decimalNumeral | hexNumeral | octalNumeral) [‘L’ | ‘l’] decimalNumeral ::= ‘0’ | nonZeroDigit {digit} hexNumeral ::= ‘0’ ‘x’ hexDigit {hexDigit} @@ -356,14 +353,12 @@ is _pt_. The numeric ranges given by these types are: |`Short` | $-2\^{15}$ to $2\^{15}-1$| |`Char` | $0$ to $2\^{16}-1$ | - ### Example ```scala 0 21 0xFFFFFFFF -42L ``` - ### Floating Point Literals ```ebnf @@ -410,7 +405,6 @@ booleanLiteral ::= ‘true’ | ‘false’ The boolean literals `true` and `false` are members of type `Boolean`. - ### Character Literals ```ebnf @@ -433,7 +427,6 @@ character `\u000A` (line feed) is not a printable character. One can use instead the escape sequence `'\n'` or the octal escape `'\12'` ([see here](#escape-sequences)). - ### String Literals ```ebnf @@ -446,7 +439,7 @@ characters are either printable unicode character or are described by [escape sequences](#escape-sequences). If the string literal contains a double quote character, it must be escaped, i.e. `"\""`. The value of a string literal is an instance of -class `String`. +class `String`. ### Example @@ -500,17 +493,16 @@ evaluates to ```scala the present string -spans three +spans three lines. ``` Method `stripMargin` is defined in class -[scala.collection.immutable.StringLike](http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.StringLike). +[scala.collection.immutable.StringLike](http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.StringLike). Because there is a predefined [implicit conversion](06-expressions.html#implicit-conversions) from `String` to `StringLike`, the method is applicable to all strings. - ### Escape Sequences The following escape sequences are recognized in character and string literals. @@ -526,7 +518,6 @@ The following escape sequences are recognized in character and string literals. | `‘\‘ ‘'‘` | `\u0027` | single quote | `'` | | `‘\‘ ‘\‘` | `\u005c` | backslash | `\` | - A character with Unicode between 0 and 255 may also be represented by an octal escape, i.e. a backslash `'\'` followed by a sequence of up to three octal characters. @@ -534,7 +525,6 @@ sequence of up to three octal characters. It is a compile time error if a backslash character in a character or string literal does not start a valid escape sequence. - ### Symbol literals ```ebnf @@ -557,7 +547,6 @@ caches weak references to `Symbol`s, thus ensuring that identical symbol literals are equivalent with respect to reference equality. - ## Whitespace and Comments Tokens may be separated by whitespace characters @@ -572,7 +561,6 @@ but are required to be properly nested. Therefore, a comment like `/* /* */` will be rejected as having an unterminated comment. - ## XML mode In order to allow literal inclusion of XML fragments, lexical analysis @@ -589,10 +577,10 @@ brace and immediately followed by a character starting an XML name. The scanner switches from XML mode to Scala mode if either -- the XML expression or the XML pattern started by the initial ‘<’ has been +- the XML expression or the XML pattern started by the initial ‘<’ has been successfully parsed, or if -- the parser encounters an embedded Scala expression or pattern and - forces the Scanner +- the parser encounters an embedded Scala expression or pattern and + forces the Scanner back to normal mode, until the Scala expression or pattern is successfully parsed. In this case, since code and XML fragments can be nested, the parser has to maintain a stack that reflects the nesting diff --git a/spec/02-identifiers-names-and-scopes.md b/spec/02-identifiers-names-and-scopes.md index bfb743dbe4a1..afa97c136c6f 100644 --- a/spec/02-identifiers-names-and-scopes.md +++ b/spec/02-identifiers-names-and-scopes.md @@ -17,14 +17,13 @@ which are collectively called _bindings_. Bindings of different kinds have a precedence defined on them: 1. Definitions and declarations that are local, inherited, or made - available by a package clause in the same compilation unit where the - definition occurs have highest precedence. + available by a package clause in the same compilation unit where the + definition occurs have highest precedence. 1. Explicit imports have next highest precedence. 1. Wildcard imports have next highest precedence. 1. Definitions made available by a package clause not in the compilation unit where the definition occurs have lowest precedence. - There are two different name spaces, one for [types](03-types.html#types) and one for [terms](06-expressions.html#expressions). The same name may designate a type and a term, depending on the context where the name is used. @@ -33,7 +32,7 @@ A binding has a _scope_ in which the entity defined by a single name can be accessed using a simple name. Scopes are nested. A binding in some inner scope _shadows_ bindings of lower precedence in the same scope as well as bindings of the same or lower precedence in outer -scopes. +scopes. Abstract value types are introduced by [type parameters](04-basic-declarations-and-definitions.html#type-parameters) and [abstract type bindings](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases). @@ -50,20 +50,19 @@ Parentheses in types can be used for grouping. define a class (of the same name as the object or package, but inaccessible to user programs). -Non-value types capture properties of identifiers that -[are not values](#non-value-types). For example, a -[type constructor](#type-constructors) does not directly specify a type of -values. However, when a type constructor is applied to the correct type -arguments, it yields a first-order type, which may be a value type. - -Non-value types are expressed indirectly in Scala. E.g., a method type is -described by writing down a method signature, which in itself is not a real -type, although it gives rise to a corresponding [method type](#method-types). -Type constructors are another example, as one can write -`type Swap[m[_, _], a,b] = m[b, a]`, but there is no syntax to write +Non-value types capture properties of identifiers that +[are not values](#non-value-types). For example, a +[type constructor](#type-constructors) does not directly specify a type of +values. However, when a type constructor is applied to the correct type +arguments, it yields a first-order type, which may be a value type. + +Non-value types are expressed indirectly in Scala. E.g., a method type is +described by writing down a method signature, which in itself is not a real +type, although it gives rise to a corresponding [method type](#method-types). +Type constructors are another example, as one can write +`type Swap[m[_, _], a,b] = m[b, a]`, but there is no syntax to write the corresponding anonymous type function directly. - ## Paths ```ebnf @@ -83,19 +82,18 @@ A path is one of the following. - The empty path ε (which cannot be written explicitly in user programs). - $C.$`this`, where $C$ references a class. The path `this` is taken as a shorthand for $C.$`this` where - $C$ is the name of the class directly enclosing the reference. + $C$ is the name of the class directly enclosing the reference. - $p.x$ where $p$ is a path and $x$ is a stable member of $p$. - _Stable members_ are packages or members introduced by object definitions or + _Stable members_ are packages or members introduced by object definitions or by value definitions of [non-volatile types](#volatile-types). - $C.$`super`$.x$ or $C.$`super`$[M].x$ - where $C$ references a class and $x$ references a - stable member of the super class or designated parent class $M$ of $C$. + where $C$ references a class and $x$ references a + stable member of the super class or designated parent class $M$ of $C$. The prefix `super` is taken as a shorthand for $C.$`super` where - $C$ is the name of the class directly enclosing the reference. + $C$ is the name of the class directly enclosing the reference. A _stable identifier_ is a path which ends in an identifier. - ## Value Types Every value in Scala has a type which is of one of the following @@ -110,7 +108,7 @@ SimpleType ::= Path ‘.’ type A singleton type is of the form $p.$`type`, where $p$ is a path pointing to a value expected to [conform](06-expressions.html#expression-typing) to `scala.AnyRef`. The type denotes the set of values -consisting of `null` and the value denoted by $p$. +consisting of `null` and the value denoted by $p$. A _stable type_ is either a singleton type or a type which is declared to be a subtype of trait `scala.Singleton`. @@ -122,11 +120,11 @@ SimpleType ::= SimpleType ‘#’ id ``` A type projection $T$#$x$ references the type member named -$x$ of type $T$. +$x$ of type $T$. @@ -162,8 +160,6 @@ with a type member `Node` and the standard class `scala.Int`, |scala.Int | scala.type#Int | |data.maintable.Node | data.maintable.type#Node | - - ### Parameterized Types ```ebnf @@ -172,7 +168,7 @@ TypeArgs ::= ‘[’ Types ‘]’ ``` A parameterized type $T[ U_1 , \ldots , U_n ]$ consists of a type -designator $T$ and type parameters $U_1 , \ldots , U_n$ where +designator $T$ and type parameters $U_1 , \ldots , U_n$ where $n \geq 1$. $T$ must refer to a type constructor which takes $n$ type parameters $a_1 , \ldots , a_n$. @@ -270,7 +266,6 @@ The following type adds the `@suspendable` annotation to the type `String`: String @suspendable ``` - ### Compound Types ```ebnf @@ -283,7 +278,7 @@ RefineStat ::= Dcl ``` A compound type $T_1$ `with` … `with` $T_n \\{ R \\}$ -represents objects with members as given in the component types +represents objects with members as given in the component types $T_1 , \ldots , T_n$ and the refinement $\\{ R \\}$. A refinement $\\{ R \\}$ contains declarations and type definitions. If a declaration or definition overrides a declaration or definition in @@ -291,7 +286,7 @@ one of the component types $T_1 , \ldots , T_n$, the usual rules for [overriding](05-classes-and-objects.html#overriding) apply; otherwise the declaration or definition is said to be “structural” [^2]. -[^2]: A reference to a structurally defined member (method call or access +[^2]: A reference to a structurally defined member (method call or access to a value or variable) may generate binary code that is significantly slower than an equivalent code to a non-structural member. @@ -341,7 +336,6 @@ Although `Bird` and `Plane` do not share any parent class other than refinement with structural declarations to accept any object that declares a value `callsign` and a `fly` method. - ### Infix Types ```ebnf @@ -350,7 +344,7 @@ InfixType ::= CompoundType {id [nl] CompoundType} An infix type $T_1$ `op` $T_2$ consists of an infix operator `op` which gets applied to two type operands $T_1$ and -$T_2$. The type is equivalent to the type application +$T_2$. The type is equivalent to the type application `op`$[T_1, T_2]$. The infix operator `op` may be an arbitrary identifier. @@ -360,13 +354,13 @@ of a type operator is determined as for term operators: type operators ending in a colon ‘:’ are right-associative; all other operators are left-associative. -In a sequence of consecutive type infix operations +In a sequence of consecutive type infix operations $t_0 \, \mathit{op} \, t_1 \, \mathit{op_2} \, \ldots \, \mathit{op_n} \, t_n$, all operators $\mathit{op}\_1 , \ldots , \mathit{op}\_n$ must have the same associativity. If they are all left-associative, the sequence is -interpreted as +interpreted as $(\ldots (t_0 \mathit{op_1} t_1) \mathit{op_2} \ldots) \mathit{op_n} t_n$, -otherwise it is interpreted as +otherwise it is interpreted as $t_0 \mathit{op_1} (t_1 \mathit{op_2} ( \ldots \mathit{op_n} t_n) \ldots)$. ### Function Types @@ -380,25 +374,25 @@ FunctionArgs ::= InfixType The type $(T_1 , \ldots , T_n) \Rightarrow U$ represents the set of function values that take arguments of types $T1 , \ldots , Tn$ and yield results of type $U$. In the case of exactly one argument type -$T \Rightarrow U$ is a shorthand for $(T) \Rightarrow U$. +$T \Rightarrow U$ is a shorthand for $(T) \Rightarrow U$. An argument type of the form $\Rightarrow T$ represents a [call-by-name parameter](04-basic-declarations-and-definitions.html#by-name-parameters) of type $T$. Function types associate to the right, e.g. -$S \Rightarrow T \Rightarrow U$ is the same as +$S \Rightarrow T \Rightarrow U$ is the same as $S \Rightarrow (T \Rightarrow U)$. Function types are shorthands for class types that define `apply` -functions. Specifically, the $n$-ary function type +functions. Specifically, the $n$-ary function type $(T_1 , \ldots , T_n) \Rightarrow U$ is a shorthand for the class type `Function$_n$[T1 , … , $T_n$, U]`. Such class types are defined in the Scala library for $n$ between 0 and 9 as follows. ```scala -package scala +package scala trait Function_n[-T1 , … , -T$_n$, +R] { - def apply(x1: T1 , … , x$_n$: T$_n$): R - override def toString = "" + def apply(x1: T1 , … , x$_n$: T$_n$): R + override def toString = "" } ``` @@ -409,28 +403,28 @@ result type and contravariant in their argument types. ```ebnf Type ::= InfixType ExistentialClauses -ExistentialClauses ::= ‘forSome’ ‘{’ ExistentialDcl +ExistentialClauses ::= ‘forSome’ ‘{’ ExistentialDcl {semi ExistentialDcl} ‘}’ -ExistentialDcl ::= ‘type’ TypeDcl +ExistentialDcl ::= ‘type’ TypeDcl | ‘val’ ValDcl ``` An existential type has the form `$T$ forSome { $Q$ }` -where $Q$ is a sequence of +where $Q$ is a sequence of [type declarations](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases). -Let +Let $t_1[\mathit{tps}\_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}\_n] >: L_n <: U_n$ be the types declared in $Q$ (any of the type parameter sections `[ $\mathit{tps}_i$ ]` might be missing). The scope of each type $t_i$ includes the type $T$ and the existential clause -$Q$. -The type variables $t_i$ are said to be _bound_ in the type +$Q$. +The type variables $t_i$ are said to be _bound_ in the type `$T$ forSome { $Q$ }`. Type variables which occur in a type $T$ but which are not bound in $T$ are said to be _free_ in $T$. -A _type instance_ of `$T$ forSome { $Q$ }` +A _type instance_ of `$T$ forSome { $Q$ }` is a type $\sigma T$ where $\sigma$ is a substitution over $t_1 , \ldots , t_n$ such that, for each $i$, $\sigma L_i <: \sigma t_i <: \sigma U_i$. The set of values denoted by the existential type `$T$ forSome {$\,Q\,$}` @@ -457,21 +451,20 @@ is equivalent to 1. An empty quantification can be dropped. E.g., `$T$ forSome { }` is equivalent to $T$. 1. An existential type `$T$ forSome { $Q$ }` where $Q$ contains -a clause `type $t[\mathit{tps}] >: L <: U$` is equivalent -to the type `$T'$ forSome { $Q$ }` where $T'$ results from $T$ by replacing +a clause `type $t[\mathit{tps}] >: L <: U$` is equivalent +to the type `$T'$ forSome { $Q$ }` where $T'$ results from $T$ by replacing every [covariant occurrence](04-basic-declarations-and-definitions.html#variance-annotations) of $t$ in $T$ by $U$ and by replacing every contravariant occurrence of $t$ in $T$ by $L$. - #### Existential Quantification over Values As a syntactic convenience, the bindings clause in an existential type may also contain -value declarations `val $x$: $T$`. +value declarations `val $x$: $T$`. An existential type `$T$ forSome { $Q$; val $x$: $S\,$;$\,Q'$ }` is treated as a shorthand for the type -`$T'$ forSome { $Q$; type $t$ <: $S$ with Singleton; $Q'$ }`, where $t$ is a -fresh type name and $T'$ results from $T$ by replacing every occurrence of +`$T'$ forSome { $Q$; type $t$ <: $S$ with Singleton; $Q'$ }`, where $t$ is a +fresh type name and $T'$ results from $T$ by replacing every occurrence of `$x$.type` with $t$. #### Placeholder Syntax for Existential Types @@ -482,17 +475,17 @@ WildcardType ::= ‘_’ TypeBounds Scala supports a placeholder syntax for existential types. A _wildcard type_ is of the form `_$\;$>:$\,L\,$<:$\,U$`. Both bound -clauses may be omitted. If a lower bound clause `>:$\,L$` is missing, +clauses may be omitted. If a lower bound clause `>:$\,L$` is missing, `>:$\,$scala.Nothing` -is assumed. If an upper bound clause `<:$\,U$` is missing, -`<:$\,$scala.Any` is assumed. A wildcard type is a shorthand for an -existentially quantified type variable, where the existential quantification is +is assumed. If an upper bound clause `<:$\,U$` is missing, +`<:$\,$scala.Any` is assumed. A wildcard type is a shorthand for an +existentially quantified type variable, where the existential quantification is implicit. A wildcard type must appear as type argument of a parameterized type. -Let $T = p.c[\mathit{targs},T,\mathit{targs}']$ be a parameterized type where +Let $T = p.c[\mathit{targs},T,\mathit{targs}']$ be a parameterized type where $\mathit{targs}, \mathit{targs}'$ may be empty and -$T$ is a wildcard type `_$\;$>:$\,L\,$<:$\,U$`. Then $T$ is equivalent to the +$T$ is a wildcard type `_$\;$>:$\,L\,$<:$\,U$`. Then $T$ is equivalent to the existential type @@ -500,7 +493,7 @@ type $p.c[\mathit{targs},t,\mathit{targs}']$ forSome { type $t$ >: $L$ <: $U$ } ``` -where $t$ is some fresh type variable. +where $t$ is some fresh type variable. Wildcard types may also appear as parts of [infix types](#infix-types) , [function types](#function-types), or [tuple types](#tuple-types). @@ -562,20 +555,18 @@ List[java.lang.Number] forSome { type T <: java.lang.Number } which is in turn equivalent (by simplification rules 2 and 3 above) to `List[java.lang.Number]`. - ## Non-Value Types The types explained in the following do not denote sets of values, nor do they appear explicitly in programs. They are introduced in this report as the internal types of defined identifiers. - ### Method Types -A method type is denoted internally as $(\mathit{Ps})U$, where $(\mathit{Ps})$ +A method type is denoted internally as $(\mathit{Ps})U$, where $(\mathit{Ps})$ is a sequence of parameter names and types $(p_1:T_1 , \ldots , p_n:T_n)$ for some $n \geq 0$ and $U$ is a (value or method) type. This type -represents named methods that take arguments named $p_1 , \ldots , p_n$ +represents named methods that take arguments named $p_1 , \ldots , p_n$ of types $T_1 , \ldots , T_n$ and that return a result of type $U$. @@ -594,7 +585,7 @@ corresponding function type. ###### Example The declarations - + ``` def a: Int def b (x: Int): Boolean @@ -612,8 +603,8 @@ c: (Int) (String, String) String ### Polymorphic Method Types A polymorphic method type is denoted internally as `[$\mathit{tps}\,$]$T$` where -`[$\mathit{tps}\,$]` is a type parameter section -`[$a_1$ >: $L_1$ <: $U_1 , \ldots , a_n$ >: $L_n$ <: $U_n$]` +`[$\mathit{tps}\,$]` is a type parameter section +`[$a_1$ >: $L_1$ <: $U_1 , \ldots , a_n$ >: $L_n$ <: $U_n$]` for some $n \geq 0$ and $T$ is a (value or method) type. This type represents named methods that take type arguments `$S_1 , \ldots , S_n$` which @@ -640,8 +631,8 @@ union : [A >: Nothing <: Comparable[A]] (x: Set[A], xs: Set[A]) Set[A] ### Type Constructors A type constructor is represented internally much like a polymorphic method type. -`[$\pm$ $a_1$ >: $L_1$ <: $U_1 , \ldots , \pm a_n$ >: $L_n$ <: $U_n$] $T$` -represents a type that is expected by a +`[$\pm$ $a_1$ >: $L_1$ <: $U_1 , \ldots , \pm a_n$ >: $L_n$ <: $U_n$] $T$` +represents a type that is expected by a [type constructor parameter](04-basic-declarations-and-definitions.html#type-parameters) or an [abstract type constructor binding](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases) with the corresponding type parameter clause. @@ -649,7 +640,7 @@ the corresponding type parameter clause. ###### Example Consider this fragment of the `Iterable[+X]` class: - + ``` trait Iterable[+X] { def flatMap[newType[+X] <: Iterable[X], S](f: X => newType[S]): newType[S] @@ -660,7 +651,6 @@ Conceptually, the type constructor `Iterable` is a name for the anonymous type `[+X] Iterable[X]`, which may be passed to the `newType` type constructor parameter in `flatMap`. - - ## Base Types and Member Definitions Types of class members depend on the way the members are referenced. @@ -704,7 +693,6 @@ Central here are three notions, namely: prefix type $S$, 1. the notion of the set of member bindings of some type $T$. - These notions are defined mutually recursively as follows. 1. The set of _base types_ of a type is a set of class types, @@ -714,25 +702,25 @@ These notions are defined mutually recursively as follows. `$T_1$ with … with $T_n$ { $R$ }`. - The base types of an aliased type are the base types of its alias. - The base types of an abstract type are the base types of its upper bound. - - The base types of a parameterized type + - The base types of a parameterized type `$C$[$T_1 , \ldots , T_n$]` are the base types - of type $C$, where every occurrence of a type parameter $a_i$ + of type $C$, where every occurrence of a type parameter $a_i$ of $C$ has been replaced by the corresponding parameter type $T_i$. - The base types of a singleton type `$p$.type` are the base types of the type of $p$. - - The base types of a compound type + - The base types of a compound type `$T_1$ with $\ldots$ with $T_n$ { $R$ }` are the _reduced union_ of the base - classes of all $T_i$'s. This means: + classes of all $T_i$'s. This means: Let the multi-set $\mathscr{S}$ be the multi-set-union of the base types of all $T_i$'s. If $\mathscr{S}$ contains several type instances of the same class, say `$S^i$#$C$[$T^i_1 , \ldots , T^i_n$]` $(i \in I)$, then - all those instances + all those instances are replaced by one of them which conforms to all - others. It is an error if no such instance exists. It follows that the + others. It is an error if no such instance exists. It follows that the reduced union, if it exists, - produces a set of class types, where different types are instances of + produces a set of class types, where different types are instances of different classes. - The base types of a type selection `$S$#$T$` are determined as follows. If $T$ is an alias or abstract type, the @@ -747,26 +735,26 @@ These notions are defined mutually recursively as follows. makes sense only if the prefix type $S$ has a type instance of class $C$ as a base type, say `$S'$#$C$[$T_1 , \ldots , T_n$]`. Then we define as follows. - - If `$S$ = $\epsilon$.type`, then $T$ in $C$ seen from $S$ is + - If `$S$ = $\epsilon$.type`, then $T$ in $C$ seen from $S$ is $T$ itself. - Otherwise, if $S$ is an existential type `$S'$ forSome { $Q$ }`, and - $T$ in $C$ seen from $S'$ is $T'$, + $T$ in $C$ seen from $S'$ is $T'$, then $T$ in $C$ seen from $S$ is `$T'$ forSome {$\,Q\,$}`. - Otherwise, if $T$ is the $i$'th type parameter of some class $D$, then - - If $S$ has a base type `$D$[$U_1 , \ldots , U_n$]`, for some type - parameters `[$U_1 , \ldots , U_n$]`, then $T$ in $C$ seen from $S$ + - If $S$ has a base type `$D$[$U_1 , \ldots , U_n$]`, for some type + parameters `[$U_1 , \ldots , U_n$]`, then $T$ in $C$ seen from $S$ is $U_i$. - Otherwise, if $C$ is defined in a class $C'$, then $T$ in $C$ seen from $S$ is the same as $T$ in $C'$ seen from $S'$. - - Otherwise, if $C$ is not defined in another class, then + - Otherwise, if $C$ is not defined in another class, then $T$ in $C$ seen from $S$ is $T$ itself. - Otherwise, if $T$ is the singleton type `$D$.this.type` for some class $D$ then - - If $D$ is a subclass of $C$ and $S$ has a type instance of class $D$ + - If $D$ is a subclass of $C$ and $S$ has a type instance of class $D$ among its base types, then $T$ in $C$ seen from $S$ is $S$. - Otherwise, if $C$ is defined in a class $C'$, then $T$ in $C$ seen from $S$ is the same as $T$ in $C'$ seen from $S'$. - - Otherwise, if $C$ is not defined in another class, then + - Otherwise, if $C$ is not defined in another class, then $T$ in $C$ seen from $S$ is $T$ itself. - If $T$ is some other type, then the described mapping is performed to all its type components. @@ -787,8 +775,6 @@ These notions are defined mutually recursively as follows. binding $d_T$ of the type `T` in `S`. In that case, we also say that `S#T` _is defined by_ $d_T$. - - ## Relations between types We define two relations between types. @@ -798,7 +784,6 @@ We define two relations between types. |Equivalence |$T \equiv U$ |$T$ and $U$ are interchangeable in all contexts. | |Conformance |$T <: U$ |Type $T$ conforms to type $U$. | - ### Equivalence Equivalence $(\equiv)$ between types is the smallest congruence [^congruence] such that @@ -812,7 +797,7 @@ the following holds: consisting only of package or object selectors and ending in $O$, then `$O$.this.type $\equiv p$.type`. - Two [compound types](#compound-types) are equivalent if the sequences - of their component are pairwise equivalent, and occur in the same order, and + of their component are pairwise equivalent, and occur in the same order, and their refinements are equivalent. Two refinements are equivalent if they bind the same names and the modifiers, types and bounds of every declared entity are equivalent in both refinements. @@ -822,43 +807,42 @@ the following holds: - they have the same number of parameters; and - corresponding parameters have equivalent types. Note that the names of parameters do not matter for method type equivalence. -- Two [polymorphic method types](#polymorphic-method-types) are equivalent if - they have the same number of type parameters, and, after renaming one set of +- Two [polymorphic method types](#polymorphic-method-types) are equivalent if + they have the same number of type parameters, and, after renaming one set of type parameters by another, the result types as well as lower and upper bounds of corresponding type parameters are equivalent. -- Two [existential types](#existential-types) +- Two [existential types](#existential-types) are equivalent if they have the same number of quantifiers, and, after renaming one list of type quantifiers by another, the quantified types as well as lower and upper bounds of corresponding quantifiers are equivalent. -- Two [type constructors](#type-constructors) are equivalent if they have the - same number of type parameters, and, after renaming one list of type - parameters by another, the result types as well as variances, lower and upper +- Two [type constructors](#type-constructors) are equivalent if they have the + same number of type parameters, and, after renaming one list of type + parameters by another, the result types as well as variances, lower and upper bounds of corresponding type parameters are equivalent. - [^congruence]: A congruence is an equivalence relation which is closed under formation of contexts [^implicit]: A method type is implicit if the parameter section that defines it starts with the `implicit` keyword. ### Conformance -The conformance relation $(<:)$ is the smallest +The conformance relation $(<:)$ is the smallest transitive relation that satisfies the following conditions. - Conformance includes equivalence. If $T \equiv U$ then $T <: U$. -- For every value type $T$, `scala.Nothing <: $T$ <: scala.Any`. -- For every type constructor $T$ (with any number of type parameters), +- For every value type $T$, `scala.Nothing <: $T$ <: scala.Any`. +- For every type constructor $T$ (with any number of type parameters), `scala.Nothing <: $T$ <: scala.Any`. - -- For every class type $T$ such that `$T$ <: scala.AnyRef` and not + +- For every class type $T$ such that `$T$ <: scala.AnyRef` and not `$T$ <: scala.NotNull` one has `scala.Null <: $T$`. - A type variable or abstract type $t$ conforms to its upper bound and - its lower bound conforms to $t$. + its lower bound conforms to $t$. - A class type or parameterized type conforms to any of its base-types. - A singleton type `$p$.type` conforms to the type of the path $p$. - A singleton type `$p$.type` conforms to the type `scala.Singleton`. - A type projection `$T$#$t$` conforms to `$U$#$t$` if $T$ conforms to $U$. -- A parameterized type `$T$[$T_1$ , … , $T_n$]` conforms to +- A parameterized type `$T$[$T_1$ , … , $T_n$]` conforms to `$T$[$U_1$ , … , $U_n$]` if the following three conditions hold for $i \in \{ 1 , \ldots , n \}$: 1. If the $i$'th type parameter of $T$ is declared covariant, then @@ -873,63 +857,61 @@ transitive relation that satisfies the following conditions. binding $d$ of a type or value $x$ in $R$ there exists a member binding of $x$ in $T$ which subsumes $d$, then $T$ conforms to the compound type `$U_1$ with $\ldots$ with $U_n$ {$R\,$}`. -- The existential type `$T$ forSome {$\,Q\,$}` conforms to +- The existential type `$T$ forSome {$\,Q\,$}` conforms to $U$ if its [skolemization](#existential-types) conforms to $U$. -- The type $T$ conforms to the existential type `$U$ forSome {$\,Q\,$}` - if $T$ conforms to one of the [type instances](#existential-types) +- The type $T$ conforms to the existential type `$U$ forSome {$\,Q\,$}` + if $T$ conforms to one of the [type instances](#existential-types) of `$U$ forSome {$\,Q\,$}`. - If - $T_i \equiv T'_i$ for $i \in \{ 1 , \ldots , n\}$ and $U$ conforms to $U'$ + $T_i \equiv T'_i$ for $i \in \{ 1 , \ldots , n\}$ and $U$ conforms to $U'$ then the method type $(p_1:T_1 , \ldots , p_n:T_n) U$ conforms to $(p'_1:T'_1 , \ldots , p'_n:T'_n) U'$. - The polymorphic type - $[a_1 >: L_1 <: U_1 , \ldots , a_n >: L_n <: U_n] T$ conforms to the + $[a_1 >: L_1 <: U_1 , \ldots , a_n >: L_n <: U_n] T$ conforms to the polymorphic type $[a_1 >: L'_1 <: U'_1 , \ldots , a_n >: L'_n <: U'_n] T'$ if, assuming - $L'_1 <: a_1 <: U'_1 , \ldots , L'_n <: a_n <: U'_n$ + $L'_1 <: a_1 <: U'_1 , \ldots , L'_n <: a_n <: U'_n$ one has $T <: T'$ and $L_i <: L'_i$ and $U'_i <: U_i$ for $i \in \{ 1 , \ldots , n \}$. -- Type constructors $T$ and $T'$ follow a similar discipline. We characterize +- Type constructors $T$ and $T'$ follow a similar discipline. We characterize $T$ and $T'$ by their type parameter clauses $[a_1 , \ldots , a_n]$ and - $[a_1' , \ldots , a_n']$, where an $a_i$ or $a_i'$ may include a variance - annotation, a higher-order type parameter clause, and bounds. Then, $T$ - conforms to $T'$ if any list $[t_1 , \ldots , t_n]$ -- with declared - variances, bounds and higher-order type parameter clauses -- of valid type - arguments for $T'$ is also a valid list of type arguments for $T$ and - $T[t_1 , \ldots , t_n] <: T'[t_1 , \ldots , t_n]$. Note that this entails + $[a_1' , \ldots , a_n']$, where an $a_i$ or $a_i'$ may include a variance + annotation, a higher-order type parameter clause, and bounds. Then, $T$ + conforms to $T'$ if any list $[t_1 , \ldots , t_n]$ -- with declared + variances, bounds and higher-order type parameter clauses -- of valid type + arguments for $T'$ is also a valid list of type arguments for $T$ and + $T[t_1 , \ldots , t_n] <: T'[t_1 , \ldots , t_n]$. Note that this entails that: - - The bounds on $a_i$ must be weaker than the corresponding bounds declared - for $a'_i$. - - The variance of $a_i$ must match the variance of $a'_i$, where covariance + - The bounds on $a_i$ must be weaker than the corresponding bounds declared + for $a'_i$. + - The variance of $a_i$ must match the variance of $a'_i$, where covariance matches covariance, contravariance matches contravariance and any variance matches invariance. - Recursively, these restrictions apply to the corresponding higher-order type parameter clauses of $a_i$ and $a'_i$. - A declaration or definition in some compound type of class type $C$ _subsumes_ another declaration of the same name in some compound type or class type $C'$, if one of the following holds. -- A value declaration or definition that defines a name $x$ with type $T$ - subsumes a value or method declaration that defines $x$ with type $T'$, provided +- A value declaration or definition that defines a name $x$ with type $T$ + subsumes a value or method declaration that defines $x$ with type $T'$, provided $T <: T'$. -- A method declaration or definition that defines a name $x$ with type $T$ - subsumes a method declaration that defines $x$ with type $T'$, provided +- A method declaration or definition that defines a name $x$ with type $T$ + subsumes a method declaration that defines $x$ with type $T'$, provided $T <: T'$. - A type alias - `type $t$[$T_1$ , … , $T_n$] = $T$` subsumes a type alias - `type $t$[$T_1$ , … , $T_n$] = $T'$` if $T \equiv T'$. + `type $t$[$T_1$ , … , $T_n$] = $T$` subsumes a type alias + `type $t$[$T_1$ , … , $T_n$] = $T'$` if $T \equiv T'$. - A type declaration `type $t$[$T_1$ , … , $T_n$] >: $L$ <: $U$` subsumes - a type declaration `type $t$[$T_1$ , … , $T_n$] >: $L'$ <: $U'$` if + a type declaration `type $t$[$T_1$ , … , $T_n$] >: $L'$ <: $U'$` if $L' <: L$ and $U <: U'$. - A type or class definition that binds a type name $t$ subsumes an abstract type declaration `type t[$T_1$ , … , $T_n$] >: L <: U` if $L <: t <: U$. - The $(<:)$ relation forms pre-order between types, i.e. it is transitive and reflexive. _least upper bounds_ and _greatest lower bounds_ of a set of types @@ -961,23 +943,20 @@ greatest lower of `A` and `B`. If there are several least upper bounds or greatest lower bounds, the Scala compiler is free to pick any one of them. - [^4]: The current Scala compiler limits the nesting level of parameterization in such bounds to be at most two deeper than the maximum nesting level of the operand types - - ### Weak Conformance -In some situations Scala uses a more general conformance relation. A -type $S$ _weakly conforms_ +In some situations Scala uses a more general conformance relation. A +type $S$ _weakly conforms_ to a type $T$, written $S <:_w T$, if $S <: T$ or both $S$ and $T$ are primitive number types and $S$ precedes $T$ in the following ordering. ```scala -Byte $<:_w$ Short +Byte $<:_w$ Short Short $<:_w$ Int Char $<:_w$ Int Int $<:_w$ Long @@ -988,14 +967,13 @@ Float $<:_w$ Double A _weak least upper bound_ is a least upper bound with respect to weak conformance. - ## Volatile Types -Type volatility approximates the possibility that a type parameter or abstract +Type volatility approximates the possibility that a type parameter or abstract type instance -of a type does not have any non-null values. A value member of a volatile type +of a type does not have any non-null values. A value member of a volatile type cannot appear in a [path](#paths). - + A type is _volatile_ if it falls into one of four categories: A compound type `$T_1$ with … with $T_n$ {$R\,$}` @@ -1007,14 +985,13 @@ is volatile if one of the following two conditions hold. to the compound type, or 1. one of $T_1 , \ldots , T_n$ is a singleton type. - Here, a type $S$ _contributes an abstract member_ to a type $T$ if $S$ contains an abstract member that is also a member of $T$. A refinement $R$ contributes an abstract member to a type $T$ if $R$ contains an abstract declaration which is also a member of $T$. A type designator is volatile if it is an alias of a volatile type, or -if it designates a type parameter or abstract type that has a volatile type as +if it designates a type parameter or abstract type that has a volatile type as its upper bound. A singleton type `$p$.type` is volatile, if the underlying @@ -1023,7 +1000,6 @@ type of path $p$ is volatile. An existential type `$T$ forSome {$\,Q\,$}` is volatile if $T$ is volatile. - ## Type Erasure A type is called _generic_ if it contains type arguments or type variables. @@ -1036,20 +1012,19 @@ The erasure mapping is defined as follows. - The erasure of the parameterized type `scala.Array$[T_1]$` is `scala.Array$[|T_1|]$`. - The erasure of every other parameterized type $T[T_1 , \ldots , T_n]$ is $|T|$. -- The erasure of a singleton type `$p$.type` is the +- The erasure of a singleton type `$p$.type` is the erasure of the type of $p$. - The erasure of a type projection `$T$#$x$` is `|$T$|#$x$`. -- The erasure of a compound type - `$T_1$ with $\ldots$ with $T_n$ {$R\,$}` is the erasure of the intersection +- The erasure of a compound type + `$T_1$ with $\ldots$ with $T_n$ {$R\,$}` is the erasure of the intersection dominator of $T_1 , \ldots , T_n$. - The erasure of an existential type `$T$ forSome {$\,Q\,$}` is $|T|$. The _intersection dominator_ of a list of types $T_1 , \ldots , T_n$ is computed as follows. -Let $T_{i_1} , \ldots , T_{i_m}$ be the subsequence of types $T_i$ -which are not supertypes of some other type $T_j$. +Let $T_{i_1} , \ldots , T_{i_m}$ be the subsequence of types $T_i$ +which are not supertypes of some other type $T_j$. If this subsequence contains a type designator $T_c$ that refers to a class -which is not a trait, +which is not a trait, the intersection dominator is $T_c$. Otherwise, the intersection dominator is the first element of the subsequence, $T_{i_1}$. - diff --git a/spec/04-basic-declarations-and-definitions.md b/spec/04-basic-declarations-and-definitions.md index 358a4765ff3e..ed7e4c625e5e 100644 --- a/spec/04-basic-declarations-and-definitions.md +++ b/spec/04-basic-declarations-and-definitions.md @@ -6,7 +6,6 @@ chapter: 4 # Basic Declarations and Definitions - ```ebnf Dcl ::= ‘val’ ValDcl | ‘var’ VarDcl @@ -40,7 +39,6 @@ between and including $s_i$ and $s_j$, - $s_k$ cannot be a variable definition. - If $s_k$ is a value definition, it must be lazy. - - - ## Value Declarations and Definitions ```ebnf Dcl ::= ‘val’ ValDcl ValDcl ::= ids ‘:’ Type -PatVarDef ::= ‘val’ PatDef +PatVarDef ::= ‘val’ PatDef PatDef ::= Pattern2 {‘,’ Pattern2} [‘:’ Type] ‘=’ Expr ids ::= id {‘,’ id} ``` @@ -114,10 +109,10 @@ A value declaration `val $x$: $T$` introduces $x$ as a name of a value of type $T$. A value definition `val $x$: $T$ = $e$` defines $x$ as a -name of the value that results from the evaluation of $e$. +name of the value that results from the evaluation of $e$. If the value definition is not recursive, the type $T$ may be omitted, in which case the [packed type](06-expressions.html#expression-typing) of -expression $e$ is assumed. If a type $T$ is given, then $e$ is expected to +expression $e$ is assumed. If a type $T$ is given, then $e$ is expected to conform to it. Evaluation of the value definition implies evaluation of its @@ -187,17 +182,15 @@ val x = x$\$$._1 val xs = x$\$$._2 ``` - The name of any declared or defined value may not end in `_=`. -A value declaration `val $x_1 , \ldots , x_n$: $T$` is a shorthand for the +A value declaration `val $x_1 , \ldots , x_n$: $T$` is a shorthand for the sequence of value declarations `val $x_1$: $T$; ...; val $x_n$: $T$`. -A value definition `val $p_1 , \ldots , p_n$ = $e$` is a shorthand for the +A value definition `val $p_1 , \ldots , p_n$ = $e$` is a shorthand for the sequence of value definitions `val $p_1$ = $e$; ...; val $p_n$ = $e$`. -A value definition `val $p_1 , \ldots , p_n: T$ = $e$` is a shorthand for the +A value definition `val $p_1 , \ldots , p_n: T$ = $e$` is a shorthand for the sequence of value definitions `val $p_1: T$ = $e$; ...; val $p_n: T$ = $e$`. - ## Variable Declarations and Definitions ```ebnf @@ -212,7 +205,7 @@ A variable declaration `var $x$: $T$` is equivalent to the declarations of both a _getter function_ $x$ *and* a _setter function_ `$x$_=`: ```scala -def $x$: $T$ +def $x$: $T$ def $x$_= ($y$: $T$): Unit ``` @@ -222,13 +215,13 @@ using a variable definition, or by defining the corresponding setter and getter A variable definition `var $x$: $T$ = $e$` introduces a mutable variable with type $T$ and initial value as given by the expression $e$. The type $T$ can be omitted, in which case the type of -$e$ is assumed. If $T$ is given, then $e$ is expected to +$e$ is assumed. If $T$ is given, then $e$ is expected to [conform to it](06-expressions.html#expression-typing). Variable definitions can alternatively have a [pattern](08-pattern-matching.html#patterns) as left-hand side. A variable definition `var $p$ = $e$` where $p$ is a pattern other -than a simple name or a name followed by a colon and a type is expanded in the same way +than a simple name or a name followed by a colon and a type is expanded in the same way as a [value definition](#value-declarations-and-definitions) `val $p$ = $e$`, except that the free names in $p$ are introduced as mutable variables, not values. @@ -249,7 +242,6 @@ The default value depends on the type $T$ as follows: |`()` | `Unit` | |`null` | all other types | - When they occur as members of a template, both forms of variable definition also introduce a getter function $x$ which returns the value currently assigned to the variable, as well as a setter function @@ -291,13 +283,12 @@ d.hours = 8; d.minutes = 30; d.seconds = 0 d.hours = 25 // throws a DateError exception ``` - -A variable declaration `var $x_1 , \ldots , x_n$: $T$` is a shorthand for the +A variable declaration `var $x_1 , \ldots , x_n$: $T$` is a shorthand for the sequence of variable declarations `var $x_1$: $T$; ...; var $x_n$: $T$`. -A variable definition `var $x_1 , \ldots , x_n$ = $e$` is a shorthand for the +A variable definition `var $x_1 , \ldots , x_n$ = $e$` is a shorthand for the sequence of variable definitions `var $x_1$ = $e$; ...; var $x_n$ = $e$`. -A variable definition `var $x_1 , \ldots , x_n: T$ = $e$` is a shorthand for -the sequence of variable definitions +A variable definition `var $x_1 , \ldots , x_n: T$ = $e$` is a shorthand for +the sequence of variable definitions `var $x_1: T$ = $e$; ...; var $x_n: T$ = $e$`. ## Type Declarations and Type Aliases @@ -341,12 +332,12 @@ have a type parameter clause, e.g. `type $t$[$\mathit{tps}\,$] = $T$`. The scop of a type parameter extends over the right hand side $T$ and the type parameter clause $\mathit{tps}$ itself. -The scope rules for [definitions](#basic-declarations-and-definitions) +The scope rules for [definitions](#basic-declarations-and-definitions) and [type parameters](#function-declarations-and-definitions) make it possible that a type name appears in its own bound or in its right-hand side. However, it is a static error if a type alias refers recursively to the defined type constructor itself. -That is, the type $T$ in a type alias `type $t$[$\mathit{tps}\,$] = $T$` may not +That is, the type $T$ in a type alias `type $t$[$\mathit{tps}\,$] = $T$` may not refer directly or indirectly to the name $t$. It is also an error if an abstract type is directly or indirectly its own upper or lower bound. @@ -400,7 +391,6 @@ As a consequence, for any two types $S$ and $T$, the type val x: Pair[Int, String] = new Pair(1, "abc") ``` - ## Type Parameters ```ebnf @@ -413,7 +403,7 @@ Type parameters appear in type definitions, class definitions, and function definitions. In this section we consider only type parameter definitions with lower bounds `>: $L$` and upper bounds `<: $U$` whereas a discussion of context bounds -`: $U$` and view bounds `<% $U$` +`: $U$` and view bounds `<% $U$` is deferred to [here](07-implicit-parameters-and-views.html#context-bounds-and-view-bounds). The most general form of a first-order type parameter is @@ -464,7 +454,6 @@ The following type parameter clauses are illegal: // not conform to upper bound `B'. ``` - ## Variance Annotations Variance annotations indicate how instances of parameterized types @@ -475,17 +464,17 @@ missing variance indication indicates an invariant dependency. A variance annotation constrains the way the annotated type variable may appear in the type or class which binds the type parameter. In a -type definition `type $T$[$\mathit{tps}\,$] = $S$`, or a type +type definition `type $T$[$\mathit{tps}\,$] = $S$`, or a type declaration `type $T$[$\mathit{tps}\,$] >: $L$ <: $U$` type parameters labeled ‘+’ must only appear in covariant position whereas type parameters labeled ‘-’ must only appear in contravariant position. Analogously, for a class definition -`class $C$[$\mathit{tps}\,$]($\mathit{ps}\,$) extends $T$ { $x$: $S$ => ...}`, +`class $C$[$\mathit{tps}\,$]($\mathit{ps}\,$) extends $T$ { $x$: $S$ => ...}`, type parameters labeled ‘+’ must only appear in covariant position in the self type $S$ and the template $T$, whereas type parameters labeled ‘-’ must only appear in contravariant -position. +position. The variance position of a type parameter in a type or template is defined as follows. Let the opposite of covariance be contravariance, @@ -493,11 +482,11 @@ and the opposite of invariance be itself. The top-level of the type or template is always in covariant position. The variance position changes at the following constructs. -- The variance position of a method parameter is the opposite of the +- The variance position of a method parameter is the opposite of the variance position of the enclosing parameter clause. - The variance position of a type parameter is the opposite of the variance position of the enclosing type parameter clause. -- The variance position of the lower bound of a type declaration or type parameter +- The variance position of the lower bound of a type declaration or type parameter is the opposite of the variance position of the type declaration or parameter. - The type of a mutable variable is always in invariant position. - The right-hand side of a type alias is always in invariant position. @@ -508,11 +497,11 @@ changes at the following constructs. contravariant, the variance position of $T$ is the opposite of the variance position of the enclosing type `$S$[$\ldots T \ldots$ ]`. - + -References to the type parameters in +References to the type parameters in [object-private or object-protected values, types, variables, or methods](05-classes-and-objects.html#modifiers) of the class are not -checked for their variance position. In these members the type parameter may +checked for their variance position. In these members the type parameter may appear anywhere without restricting its legal variance annotations. ###### Example @@ -588,22 +577,21 @@ That is, a channel on which one can write any object can substitute for a channel on which one can write only strings. - ## Function Declarations and Definitions ```ebnf Dcl ::= ‘def’ FunDcl FunDcl ::= FunSig ‘:’ Type Def ::= ‘def’ FunDef -FunDef ::= FunSig [‘:’ Type] ‘=’ Expr +FunDef ::= FunSig [‘:’ Type] ‘=’ Expr FunSig ::= id [FunTypeParamClause] ParamClauses -FunTypeParamClause ::= ‘[’ TypeParam {‘,’ TypeParam} ‘]’ +FunTypeParamClause ::= ‘[’ TypeParam {‘,’ TypeParam} ‘]’ ParamClauses ::= {ParamClause} [[nl] ‘(’ ‘implicit’ Params ‘)’] -ParamClause ::= [nl] ‘(’ [Params] ‘)’} +ParamClause ::= [nl] ‘(’ [Params] ‘)’} Params ::= Param {‘,’ Param} Param ::= {Annotation} id [‘:’ ParamType] [‘=’ Expr] -ParamType ::= Type - | ‘=>’ Type +ParamType ::= Type + | ‘=>’ Type | Type ‘*’ ``` @@ -624,8 +612,8 @@ result type, if one is given. If the function definition is not recursive, the result type may be omitted, in which case it is determined from the packed type of the function body. -A type parameter clause $\mathit{tps}$ consists of one or more -[type declarations](#type-declarations-and-type-aliases), which introduce type +A type parameter clause $\mathit{tps}$ consists of one or more +[type declarations](#type-declarations-and-type-aliases), which introduce type parameters, possibly with bounds. The scope of a type parameter includes the whole signature, including any of the type parameter bounds as well as the function body, if it is present. @@ -647,7 +635,7 @@ declaration. These methods are parametrized by the type parameter clause The `$f\$$default$\$$n` methods are inaccessible for user programs. -The scope of a formal value parameter name $x$ comprises all subsequent +The scope of a formal value parameter name $x$ comprises all subsequent parameter clauses, as well as the method return type and the function body, if they are given. Both type parameter names and value parameter names must be pairwise distinct. @@ -669,10 +657,8 @@ def compare$\$$default$\$$1[T]: Int = 0 def compare$\$$default$\$$2[T](a: T): T = a ``` - ### By-Name Parameters - ```ebnf ParamType ::= ‘=>’ Type ``` @@ -687,7 +673,7 @@ function. That is, the argument is evaluated using _call-by-name_. The by-name modifier is disallowed for parameters of classes that carry a `val` or `var` prefix, including parameters of case classes for which a `val` prefix is implicitly generated. The -by-name modifier is also disallowed for +by-name modifier is also disallowed for [implicit parameters](07-implicit-parameters-and-views.html#implicit-parameters). ###### Example @@ -700,7 +686,6 @@ def whileLoop (cond: => Boolean) (stat: => Unit): Unit indicates that both parameters of `whileLoop` are evaluated using call-by-name. - ### Repeated Parameters ```ebnf @@ -712,17 +697,17 @@ The last value parameter of a parameter section may be suffixed by _repeated_ parameter inside the method is then the sequence type `scala.Seq[$T$]`. Methods with repeated parameters `$T$*` take a variable number of arguments of type $T$. -That is, if a method $m$ with type -`($p_1:T_1 , \ldots , p_n:T_n, p_s:S$*)$U$` is applied to arguments -$(e_1 , \ldots , e_k)$ where $k \geq n$, then $m$ is taken in that application -to have type $(p_1:T_1 , \ldots , p_n:T_n, p_s:S , \ldots , p_{s'}S)U$, with +That is, if a method $m$ with type +`($p_1:T_1 , \ldots , p_n:T_n, p_s:S$*)$U$` is applied to arguments +$(e_1 , \ldots , e_k)$ where $k \geq n$, then $m$ is taken in that application +to have type $(p_1:T_1 , \ldots , p_n:T_n, p_s:S , \ldots , p_{s'}S)U$, with $k - n$ occurrences of type -$S$ where any parameter names beyond $p_s$ are fresh. The only exception to +$S$ where any parameter names beyond $p_s$ are fresh. The only exception to this rule is if the last argument is marked to be a _sequence argument_ via a `_*` type annotation. If $m$ above is applied to arguments `($e_1 , \ldots , e_n, e'$: _*)`, then the type of $m$ in -that application is taken to be +that application is taken to be `($p_1:T_1, \ldots , p_n:T_n,p_{s}:$scala.Seq[$S$])`. It is not allowed to define any default arguments in a parameter section @@ -768,7 +753,6 @@ the result `6`: sum(xs: _*) ``` - ### Procedures ```ebnf @@ -777,7 +761,7 @@ FunDef ::= FunSig [nl] ‘{’ Block ‘}’ ``` Special syntax exists for procedures, i.e. functions that return the -`Unit` value `()`. +`Unit` value `()`. A procedure declaration is a function declaration where the result type is omitted. The result type is then implicitly completed to the `Unit` type. E.g., `def $f$($\mathit{ps}$)` is equivalent to @@ -811,7 +795,6 @@ object Terminal extends Writer { } ``` - ### Method Return Type Inference A class member definition $m$ that overrides some other function $m'$ @@ -838,8 +821,6 @@ class C extends I { Here, it is OK to leave out the result type of `factorial` in `C`, even though the method is recursive. - - **Inheriting from Java Types** A template may have a Java class as its superclass and Java interfaces as its -mixins. +mixins. **Template Evaluation** Consider a template `$sc$ with $mt_1$ with $mt_n$ { $\mathit{stats}$ }`. -If this is the template of a [trait](#traits) then its _mixin-evaluation_ +If this is the template of a [trait](#traits) then its _mixin-evaluation_ consists of an evaluation of the statement sequence $\mathit{stats}$. If this is not a template of a trait, then its _evaluation_ consists of the following steps. -- First, the superclass constructor $sc$ is +- First, the superclass constructor $sc$ is [evaluated](#constructor-invocations). - Then, all base classes in the template's [linearization](#class-linearization) up to the template's superclass denoted by $sc$ are @@ -130,9 +128,8 @@ consists of the following steps. occurrence in the linearization. - Finally the statement sequence $\mathit{stats}\,$ is evaluated. - ###### Delayed Initializaton -The initialization code of an object or class (but not a trait) that follows +The initialization code of an object or class (but not a trait) that follows the superclass constructor invocation and the mixin-evaluation of the template's base classes is passed to a special hook, which is inaccessible from user @@ -145,7 +142,6 @@ method, which is defined as follows: def delayedInit(body: => Unit) ``` - ### Constructor Invocations ```ebnf @@ -156,7 +152,7 @@ Constructor invocations define the type, members, and initial state of objects created by an instance creation expression, or of parts of an object's definition which are inherited by a class or object definition. A constructor invocation is a function application -`$x$.$c$[$\mathit{targs}$]($\mathit{args}_1$)$\ldots$($\mathit{args}_n$)`, where $x$ is a +`$x$.$c$[$\mathit{targs}$]($\mathit{args}_1$)$\ldots$($\mathit{args}_n$)`, where $x$ is a [stable identifier](03-types.html#paths), $c$ is a type name which either designates a class or defines an alias type for one, $\mathit{targs}$ is a type argument list, $\mathit{args}_1 , \ldots , \mathit{args}_n$ are argument lists, and there is a @@ -171,12 +167,12 @@ it can be omitted, in which case a type argument list is synthesized using [local type inference](06-expressions.html#local-type-inference). If no explicit arguments are given, an empty list `()` is implicitly supplied. -An evaluation of a constructor invocation +An evaluation of a constructor invocation `$x$.$c$[$\mathit{targs}$]($\mathit{args}_1$)$\ldots$($\mathit{args}_n$)` consists of the following steps: - First, the prefix $x$ is evaluated. -- Then, the arguments $\mathit{args}_1 , \ldots , \mathit{args}_n$ are evaluated from +- Then, the arguments $\mathit{args}_1 , \ldots , \mathit{args}_n$ are evaluated from left to right. - Finally, the class being constructed is initialized by evaluating the template of the class referred to by $c$. @@ -188,7 +184,6 @@ inheritance relation from a class $C$ are called the _base classes_ of $C$. Bec on base classes forms in general a directed acyclic graph. A linearization of this graph is defined as follows. - ###### Definition: linearization Let $C$ be a class with template `$C_1$ with ... with $C_n$ { $\mathit{stats}$ }`. @@ -206,7 +201,6 @@ $$ \end{array} $$ - ###### Example Consider the following class definitions. @@ -245,7 +239,6 @@ For instance, the linearization of `RichIterator` is which is not a suffix of the linearization of `Iter`. - ### Class Members A class $C$ defined by a template `$C_1$ with $\ldots$ with $C_n$ { $\mathit{stats}$ }` @@ -294,8 +287,8 @@ $C_j \in \mathcal{L}(C)$ where $j < i$ which directly defines an abstract member $M'$ matching $M$. This definition also determines the [overriding](#overriding) relationships -between matching members of a class $C$ and its parents. -First, a concrete definition always overrides an abstract definition. +between matching members of a class $C$ and its parents. +First, a concrete definition always overrides an abstract definition. Second, for definitions $M$ and $M$' which are both concrete or both abstract, $M$ overrides $M'$ if $M$ appears in a class that precedes (in the linearization of $C$) the class in which $M'$ is defined. @@ -306,7 +299,6 @@ or inherited) with the same name and the same [erased type](03-types.html#type-e Finally, a template is not allowed to contain two methods (directly defined or inherited) with the same name which both define default arguments. - ###### Example Consider the trait definitions: @@ -321,12 +313,11 @@ Then trait `D` has a directly defined abstract member `h`. It inherits member `f` from trait `C` and member `g` from trait `B`. - ### Overriding -A member $M$ of class $C$ that [matches](#class-members) +A member $M$ of class $C$ that [matches](#class-members) a non-private member $M'$ of a base class of $C$ is said to _override_ that member. In this case the binding of the overriding member $M$ must [subsume](03-types.html#conformance) @@ -345,9 +336,9 @@ $M'$: labeled `protected`. - If $M'$ is not an abstract member, then $M$ must be labeled `override`. Furthermore, one of two possibilities must hold: - - either $M$ is defined in a subclass of the class where is $M'$ is defined, + - either $M$ is defined in a subclass of the class where is $M'$ is defined, - or both $M$ and $M'$ override a third member $M''$ which is defined - in a base class of both the classes containing $M$ and $M'$ + in a base class of both the classes containing $M$ and $M'$ - If $M'$ is [incomplete](#modifiers) in $C$ then $M$ must be labeled `abstract override`. - If $M$ and $M'$ are both concrete value definitions, then either none @@ -399,7 +390,6 @@ definition of type `T` in class `C`: class C extends A with B { type T <: C } ``` - ### Inheritance Closure Let $C$ be a class type. The _inheritance closure_ of $C$ is the @@ -435,9 +425,9 @@ constructor is called. In a template ``` The initial pattern definitions of $p_1 , \ldots , p_n$ are called -_early definitions_. They define fields +_early definitions_. They define fields which form part of the template. Every early definition must define -at least one variable. +at least one variable. An early definition is type-checked and evaluated in the scope which is in effect just before the template being defined, augmented by any @@ -453,7 +443,6 @@ always refer to the value that's defined there, and do not take into account overriding definitions. In other words, a block of early definitions is evaluated exactly as if it was a local bock containing a number of value definitions. - Early definitions are evaluated in the order they are being defined before the superclass constructor of the template is called. @@ -483,11 +472,10 @@ body, it would be initialized after the constructor of `Greeting`. In that case, `msg` would be initialized to `"How are you, "`. - ## Modifiers ```ebnf -Modifier ::= LocalModifier +Modifier ::= LocalModifier | AccessModifier | `override' LocalModifier ::= `abstract' @@ -630,7 +618,6 @@ initialization might lead to looping behavior. If an exception is thrown during initialization, the value is considered uninitialized, and a later access will retry to evaluate its right hand side. - ###### Example The following code illustrates the use of qualified private: @@ -653,7 +640,6 @@ package-private methods in Java. Finally, accesses to method `h` can appear anywhere within package `outerpkg`, including packages contained in it. - ###### Example A useful idiom to prevent clients of a class from constructing new instances of that class is to declare the class @@ -681,14 +667,13 @@ new m.C(0) {} // **** error: illegal inheritance from sealed class. A similar access restriction can be achieved by marking the primary constructor `private` ([example](#example-private-constructor)). - ## Class Definitions ```ebnf -TmplDef ::= `class' ClassDef -ClassDef ::= id [TypeParamClause] {Annotation} - [AccessModifier] ClassParamClauses ClassTemplateOpt -ClassParamClauses ::= {ClassParamClause} +TmplDef ::= `class' ClassDef +ClassDef ::= id [TypeParamClause] {Annotation} + [AccessModifier] ClassParamClauses ClassTemplateOpt +ClassParamClauses ::= {ClassParamClause} [[nl] `(' implicit ClassParams `)'] ClassParamClause ::= [nl] `(' [ClassParams] ')' ClassParams ::= ClassParam {`,' ClassParam} @@ -697,7 +682,7 @@ ClassParam ::= {Annotation} {Modifier} [(`val' | `var')] ClassTemplateOpt ::= `extends' ClassTemplate | [[`extends'] TemplateBody] ``` -The most general form of class definition is +The most general form of class definition is ```scala class $c$[$\mathit{tps}\,$] $as$ $m$($\mathit{ps}_1$)$\ldots$($\mathit{ps}_n$) extends $t$ $\quad(n \geq 0)$. @@ -713,16 +698,16 @@ Here, parameter section `[$\mathit{tps}\,$]` may be omitted. A class with a type parameter section is called _polymorphic_, otherwise it is called _monomorphic_. - - $as$ is a possibly empty sequence of + - $as$ is a possibly empty sequence of [annotations](11-user-defined-annotations.html#user-defined-annotations). - If any annotations are given, they apply to the primary constructor of the + If any annotations are given, they apply to the primary constructor of the class. - $m$ is an [access modifier](#modifiers) such as `private` or `protected`, possibly with a qualification. If such an access modifier is given it applies to the primary constructor of the class. - $(\mathit{ps}\_1)\ldots(\mathit{ps}\_n)$ are formal value parameter clauses for the _primary constructor_ of the class. The scope of a formal value parameter includes - all subsequent parameter sections and the template $t$. However, a formal + all subsequent parameter sections and the template $t$. However, a formal value parameter may not form part of the types of any of the parent classes or members of the class template $t$. It is illegal to define two formal value parameters with the same name. @@ -742,19 +727,18 @@ Here, - $t$ is a [template](#templates) of the form - ``` + ``` $sc$ with $mt_1$ with $\ldots$ with $mt_m$ { $\mathit{stats}$ } // $m \geq 0$ ``` which defines the base classes, behavior and initial state of objects of - the class. The extends clause - `extends $sc$ with $mt_1$ with $\ldots$ with $mt_m$` + the class. The extends clause + `extends $sc$ with $mt_1$ with $\ldots$ with $mt_m$` can be omitted, in which case `extends scala.AnyRef` is assumed. The class body `{ $\mathit{stats}$ }` may also be omitted, in which case the empty body `{}` is assumed. - This class definition defines a type `$c$[$\mathit{tps}\,$]` and a constructor which when applied to parameters conforming to types $\mathit{ps}$ initializes instances of type `$c$[$\mathit{tps}\,$]` by evaluating the template @@ -782,11 +766,10 @@ class Sensitive private () { } ``` - ### Constructor Definitions ```ebnf -FunDef ::= `this' ParamClause ParamClauses +FunDef ::= `this' ParamClause ParamClauses (`=' ConstrExpr | [nl] ConstrBlock) ConstrExpr ::= SelfInvocation | ConstrBlock @@ -814,16 +797,16 @@ to instantiate formal type parameters. The signature and the self constructor invocation of a constructor definition are type-checked and evaluated in the scope which is in effect at the point of the enclosing class definition, augmented by -any type parameters of the enclosing class and by any +any type parameters of the enclosing class and by any [early definitions](#early-definitions) of the enclosing template. The rest of the constructor expression is type-checked and evaluated as a function body in the current class. - + If there are auxiliary constructors of a class $C$, they form together with $C$'s primary [constructor](#class-definitions) an overloaded constructor -definition. The usual rules for +definition. The usual rules for [overloading resolution](06-expressions.html#overloading-resolution) apply for constructor invocations of $C$, including for the self constructor invocations in the constructor @@ -832,8 +815,7 @@ are never inherited. To prevent infinite cycles of constructor invocations, there is the restriction that every self constructor invocation must refer to a constructor definition which precedes it (i.e. it must refer to either a preceding auxiliary constructor or the -primary constructor of the class). - +primary constructor of the class). ###### Example Consider the class definition @@ -852,7 +834,6 @@ This defines a class `LinkedList` with three constructors. The second constructor constructs an singleton list, while the third one constructs a list with a given head and tail. - ## Case Classes ```ebnf @@ -860,7 +841,7 @@ TmplDef ::= `case' `class' ClassDef ``` If a class definition is prefixed with `case`, the class is said -to be a _case class_. +to be a _case class_. The formal parameters in the first parameter section of a case class are called _elements_; they are treated @@ -905,7 +886,7 @@ def unapply[$\mathit{tps}\,$]($x$: $c$[$\mathit{tps}\,$]) = x ne null ``` The name of the `unapply` method is changed to `unapplySeq` if the first -parameter section $\mathit{ps}_1$ of $c$ ends in a +parameter section $\mathit{ps}_1$ of $c$ ends in a [repeated parameter](04-basic-declarations-and-definitions.html#repeated-parameters). If a companion object $c$ exists already, no new object is created, but the `apply` and `unapply` methods are added to the existing @@ -942,7 +923,6 @@ class different from `AnyRef`. In particular: - Method `toString: String` returns a string representation which contains the name of the class and its elements. - ###### Example Here is the definition of abstract syntax for lambda calculus: @@ -985,7 +965,6 @@ This form of extensibility can be excluded by declaring the base class directly extend `Expr` must be in the same source file as `Expr`. - ### Traits ```ebnf @@ -1090,17 +1069,16 @@ methods are re-bound to refer to the corresponding implementations in `ListTable`, which is the actual supertype of `SynchronizedTable` in `MyTable`. - ## Object Definitions ```ebnf ObjectDef ::= id ClassTemplate ``` -An object definition defines a single object of a new class. Its +An object definition defines a single object of a new class. Its most general form is `object $m$ extends $t$`. Here, -$m$ is the name of the object to be defined, and +$m$ is the name of the object to be defined, and $t$ is a [template](#templates) of the form ```scala @@ -1108,7 +1086,7 @@ $sc$ with $mt_1$ with $\ldots$ with $mt_n$ { $\mathit{stats}$ } ``` which defines the base classes, behavior and initial state of $m$. -The extends clause `extends $sc$ with $mt_1$ with $\ldots$ with $mt_n$` +The extends clause `extends $sc$ with $mt_1$ with $\ldots$ with $mt_n$` can be omitted, in which case `extends scala.AnyRef` is assumed. The class body `{ $\mathit{stats}$ }` may also be omitted, in which case the empty body @@ -1128,7 +1106,7 @@ not at the point of the object definition, but is instead evaluated the first time $m$ is dereferenced during execution of the program (which might be never at all). An attempt to dereference $m$ again in the course of evaluation of the constructor leads to a infinite loop -or run-time error. +or run-time error. Other threads trying to dereference $m$ while the constructor is being evaluated block until evaluation is complete. diff --git a/spec/06-expressions.md b/spec/06-expressions.md index 7e0a5facf135..96a2558e61e2 100644 --- a/spec/06-expressions.md +++ b/spec/06-expressions.md @@ -48,7 +48,7 @@ Ascription ::= `:' InfixType ``` Expressions are composed of operators and operands. Expression forms are -discussed subsequently in decreasing order of precedence. +discussed subsequently in decreasing order of precedence. ## Expression Typing @@ -70,7 +70,6 @@ Then the _packed type_ of $e$ is $T$ forSome { type $t_1[\mathit{tps}\_1] >: L_1 <: U_1$; $\ldots$; type $t_n[\mathit{tps}\_n] >: L_n <: U_n$ }. ``` - ## Literals ```ebnf @@ -80,7 +79,6 @@ SimpleExpr ::= Literal Typing of literals is as described [here](01-lexical-syntax.html#literals); their evaluation is immediate. - ## The _Null_ Value The `null` value is of type `scala.Null`, and is thus @@ -90,15 +88,14 @@ implements methods in class `scala.AnyRef` as follows: - `eq($x\,$)` and `==($x\,$)` return `true` iff the argument $x$ is also the "null" object. -- `ne($x\,$)` and `!=($x\,$)` return true iff the +- `ne($x\,$)` and `!=($x\,$)` return true iff the argument x is not also the "null" object. - `isInstanceOf[$T\,$]` always returns `false`. - `asInstanceOf[$T\,$]` returns the [default value](04-basic-declarations-and-definitions.html#value-declarations-and-definitions) of type $T$. - `##` returns ``0``. A reference to any other member of the "null" object causes a -`NullPointerException` to be thrown. - +`NullPointerException` to be thrown. ## Designators @@ -108,9 +105,9 @@ SimpleExpr ::= Path ``` A designator refers to a named term. It can be a _simple name_ or -a _selection_. +a _selection_. -A simple name $x$ refers to a value as specified +A simple name $x$ refers to a value as specified [here](02-identifiers-names-and-scopes.html#identifiers-names-and-scopes). If $x$ is bound by a definition or declaration in an enclosing class or object $C$, it is taken to be equivalent to the selection @@ -120,7 +117,7 @@ occurrence of $x$. If $r$ is a [stable identifier](03-types.html#paths) of type $T$, the selection $r.x$ refers statically to a term member $m$ of $r$ that is identified in $T$ by -the name $x$. +the name $x$. For other expressions $e$, $e.x$ is typed as if it was `{ val $y$ = $e$; $y$.$x$ }`, for some fresh name -$y$. +$y$. The expected type of a designator's prefix is always undefined. The type of a designator is the type $T$ of the entity it refers to, with @@ -147,16 +144,14 @@ designate a constant, or conform to $\mathit{pt}$, or 1. The path $p$ designates a module. - The selection $e.x$ is evaluated by first evaluating the qualifier expression $e$, which yields an object $r$, say. The selection's result is then the member of $r$ that is either defined by $m$ or defined -by a definition overriding $m$. +by a definition overriding $m$. If that member has a type which conforms to `scala.NotNull`, the member's value must be initialized to a value different from `null`, otherwise a `scala.UnitializedError` is thrown. - ## This and Super @@ -190,7 +185,7 @@ method. @@ -1353,7 +1320,6 @@ permitted. Evaluation of a statement sequence entails evaluation of the statements in the order they are written. - ## Implicit Conversions Implicit conversions can be applied to expressions whose type does not @@ -1361,7 +1327,7 @@ match their expected type, to qualifiers in selections, and to unapplied methods available implicit conversions are given in the next two sub-sections. We say, a type $T$ is _compatible_ to a type $U$ if $T$ weakly conforms -to $U$ after applying [eta-expansion](#eta-expansion) and +to $U$ after applying [eta-expansion](#eta-expansion) and [view applications](07-implicit-parameters-and-views.html#views). ### Value Conversions @@ -1371,11 +1337,10 @@ expression $e$ which has some value type $T$ and which is type-checked with some expected type $\mathit{pt}$. #### Overloading Resolution -If an expression denotes several possible members of a class, +If an expression denotes several possible members of a class, [overloading resolution](#overloading-resolution) is applied to pick a unique member. - ###### Type Instantiation An expression $e$ of polymorphic type @@ -1386,7 +1351,7 @@ An expression $e$ of polymorphic type which does not appear as the function part of a type application is converted to a type instance of $T$ by determining with [local type inference](#local-type-inference) -instance types `$T_1 , \ldots , T_n$` +instance types `$T_1 , \ldots , T_n$` for the type variables `$a_1 , \ldots , a_n$` and implicitly embedding $e$ in the [type application](#type-applications) `$e$[$T_1 , \ldots , T_n$]`. @@ -1405,7 +1370,7 @@ type, it is converted to the same literal in that type. ###### Value Discarding If $e$ has some value type and the expected type is `Unit`, -$e$ is converted to the expected type by embedding it in the +$e$ is converted to the expected type by embedding it in the term `{ $e$; () }`. ###### View Application @@ -1416,7 +1381,7 @@ $e$ to the expected type with a [view](07-implicit-parameters-and-views.html#vie ###### Dynamic Member Selection If none of the previous conversions applies, and $e$ is a prefix of a selection $e.x$, and $e$'s type conforms to class `scala.Dynamic`, -then the selection is rewritten according to the rules for +then the selection is rewritten according to the rules for [dynamic member selection](#dynamic-member-selection). ### Method Conversions @@ -1450,7 +1415,7 @@ member. The way this is done depends on whether or not $e$ is used as a function. Let $\mathscr{A}$ be the set of members referenced by $e$. Assume first that $e$ appears as a function in an application, as in -`$e$($e_1 , \ldots , e_m$)`. +`$e$($e_1 , \ldots , e_m$)`. One first determines the set of functions that is potentially applicable based on the _shape_ of the arguments. @@ -1464,7 +1429,7 @@ a type that is defined as follows: - For a named argument `$n$ = $e$`: $\mathit{shape}(e)$. - For all other expressions: `Nothing`. -Let $\mathscr{B}$ be the set of alternatives in $\mathscr{A}$ that are +Let $\mathscr{B}$ be the set of alternatives in $\mathscr{A}$ that are [_applicable_](#function-applications) to expressions $(e_1 , \ldots , e_n)$ of types $(\mathit{shape}(e_1) , \ldots , \mathit{shape}(e_n))$. @@ -1473,7 +1438,7 @@ alternative in $\mathscr{B}$, that alternative is chosen. Otherwise, let $S_1 , \ldots , S_m$ be the vector of types obtained by typing each argument with an undefined expected type. For every -member $m$ in $\mathscr{B}$ one determines whether it is +member $m$ in $\mathscr{B}$ one determines whether it is applicable to expressions ($e_1 , \ldots , e_m$) of types $S_1 , \ldots , S_m$. It is an error if none of the members in $\mathscr{B}$ is applicable. If there is one @@ -1501,16 +1466,16 @@ question: given types $T_1 , \ldots , T_n$. - A polymorphic method of type `[$a_1$ >: $L_1$ <: $U_1 , \ldots , a_n$ >: $L_n$ <: $U_n$]$T$` is - as specific as some other member of type $S$ if $T$ is as + as specific as some other member of type $S$ if $T$ is as specific as $S$ under the assumption that for $i = 1 , \ldots , n$ each $a_i$ is an abstract type name bounded from below by $L_i$ and from above by $U_i$. - A member of any other type is always as specific as a parameterized method or a polymorphic method. -- Given two members of types $T$ and $U$ which are +- Given two members of types $T$ and $U$ which are neither parameterized nor polymorphic method types, the member of type $T$ is as specific as - the member of type $U$ if the existential dual of $T$ conforms to the existential dual of $U$. - Here, the existential dual of a polymorphic type + the member of type $U$ if the existential dual of $T$ conforms to the existential dual of $U$. + Here, the existential dual of a polymorphic type `[$a_1$ >: $L_1$ <: $U_1 , \ldots , a_n$ >: $L_n$ <: $U_n$]$T$` is `$T$ forSome { type $a_1$ >: $L_1$ <: $U_1$ $, \ldots ,$ type $a_n$ >: $L_n$ <: $U_n$}`. The existential dual of every other type is the type itself. @@ -1541,15 +1506,15 @@ in `$e$[$\mathit{targs}\,$]`. Then all alternatives in $\mathscr{A}$ which take the same number of type parameters as there are type arguments in $\mathit{targs}$ are chosen. It is an error if no such alternative exists. If there are several such alternatives, overloading resolution is -applied again to the whole expression `$e$[$\mathit{targs}\,$]`. +applied again to the whole expression `$e$[$\mathit{targs}\,$]`. Assume finally that $e$ does not appear as a function in either an application or a type application. If an expected type is given, let $\mathscr{B}$ be the set of those alternatives in $\mathscr{A}$ which are -[compatible](#implicit-conversions) to it. Otherwise, let $\mathscr{B}$ be the same +[compatible](#implicit-conversions) to it. Otherwise, let $\mathscr{B}$ be the same as $\mathscr{A}$. We choose in this case the most specific alternative among all -alternatives in $\mathscr{B}$. It is an error if there is no +alternatives in $\mathscr{B}$. It is an error if there is no alternative in $\mathscr{B}$ which is more specific than all other alternatives in $\mathscr{B}$. @@ -1575,18 +1540,17 @@ def f(x: B, y: A) = $\ldots$ Then the application `f(a, a)` is rejected for being ambiguous, since no most specific applicable signature exists. - ### Local Type Inference Local type inference infers type arguments to be passed to expressions of polymorphic type. Say $e$ is of type [$a_1$ >: $L_1$ <: $U_1 , \ldots , a_n$ >: $L_n$ <: $U_n$]$T$ and no explicit type parameters -are given. +are given. Local type inference converts this expression to a type application `$e$[$T_1 , \ldots , T_n$]`. The choice of the type arguments $T_1 , \ldots , T_n$ depends on the context in which -the expression appears and on the expected type $\mathit{pt}$. +the expression appears and on the expected type $\mathit{pt}$. There are three cases. ###### Case 1: Selections @@ -1594,7 +1558,7 @@ If the expression appears as the prefix of a selection with a name $x$, then type inference is _deferred_ to the whole expression $e.x$. That is, if $e.x$ has type $S$, it is now treated as having type [$a_1$ >: $L_1$ <: $U_1 , \ldots , a_n$ >: $L_n$ <: $U_n$]$S$, -and local type inference is applied in turn to infer type arguments +and local type inference is applied in turn to infer type arguments for $a_1 , \ldots , a_n$, using the context in which $e.x$ appears. ###### Case 2: Values @@ -1602,7 +1566,7 @@ If the expression $e$ appears as a value without being applied to value arguments, the type arguments are inferred by solving a constraint system which relates the expression's type $T$ with the expected type $\mathit{pt}$. Without loss of generality we can assume that -$T$ is a value type; if it is a method type we apply +$T$ is a value type; if it is a method type we apply [eta-expansion](#eta-expansion) to convert it to a function type. Solving means finding a substitution $\sigma$ of types $T_i$ for the type parameters $a_i$ such that @@ -1613,7 +1577,7 @@ parameters $a_i$ such that - The expression's type conforms to the expected type, i.e. $\sigma T <: \sigma \mathit{pt}$. -It is a compile time error if no such substitution exists. +It is a compile time error if no such substitution exists. If several substitutions exist, local-type inference will choose for each type variable $a_i$ a minimal or maximal type $T_i$ of the solution space. A _maximal_ type $T_i$ will be chosen if the type @@ -1722,7 +1686,6 @@ a = Int so `Int` is the type inferred for `a`. - ###### Example Consider now the definition @@ -1759,7 +1722,6 @@ a = scala.Any so `scala.Any` is the type inferred for `a`. - ### Eta Expansion _Eta-expansion_ converts an expression of method type to an @@ -1774,10 +1736,10 @@ for every argument type $T_i$ of the method ($i = 1 , \ldots , n$). The result of eta-conversion is then: ```scala -{ val $x_1$ = $e_1$; - $\ldots$ - val $x_m$ = $e_m$; - ($y_1: T_1 , \ldots , y_n: T_n$) => $e'$($y_1 , \ldots , y_n$) +{ val $x_1$ = $e_1$; + $\ldots$ + val $x_m$ = $e_m$; + ($y_1: T_1 , \ldots , y_n: T_n$) => $e'$($y_1 , \ldots , y_n$) } ``` @@ -1811,4 +1773,3 @@ is rewritten to ```scala $e$.applyDynamic("$x$", $\mathit{args}$) ``` - diff --git a/spec/07-implicit-parameters-and-views.md b/spec/07-implicit-parameters-and-views.md index e07adc9e8209..3a215e74fcc7 100644 --- a/spec/07-implicit-parameters-and-views.md +++ b/spec/07-implicit-parameters-and-views.md @@ -15,7 +15,7 @@ ParamClauses ::= {ParamClause} [nl] ‘(’ ‘implicit’ Params ‘)’ Template members and parameters labeled with an `implicit` modifier can be passed to [implicit parameters](#implicit-parameters) -and can be used as implicit conversions called [views](#views). +and can be used as implicit conversions called [views](#views). The `implicit` modifier is illegal for all type members, as well as for [top-level objects](09-top-level-definitions.html#packagings). @@ -41,7 +41,6 @@ object Monoids { } ``` - ## Implicit Parameters An implicit parameter list @@ -57,7 +56,7 @@ parameters, such arguments will be automatically provided. The actual arguments that are eligible to be passed to an implicit parameter of type $T$ fall into two categories. First, eligible are all identifiers $x$ that can be accessed at the point of the method -call without a prefix and that denote an +call without a prefix and that denote an [implicit definition](#the-implicit-modifier) or an implicit parameter. An eligible identifier may thus be a local name, or a member of an enclosing @@ -117,7 +116,6 @@ eligible object which matches the implicit formal parameter type `Monoid[Int]` is `intMonoid` so this object will be passed as implicit parameter. - This discussion also shows that implicit parameters are inferred after any type arguments are [inferred](06-expressions.html#local-type-inference). @@ -128,7 +126,7 @@ type of the list is also convertible to this type. ```scala implicit def list2ordered[A](x: List[A]) - (implicit elem2ordered: A => Ordered[A]): Ordered[List[A]] = + (implicit elem2ordered: A => Ordered[A]): Ordered[List[A]] = ... ``` @@ -145,8 +143,8 @@ define a `sort` method over ordered lists: def sort[A](xs: List[A])(implicit a2ordered: A => Ordered[A]) = ... ``` -We can apply `sort` to a list of lists of integers -`yss: List[List[Int]]` +We can apply `sort` to a list of lists of integers +`yss: List[List[Int]]` as follows: ```scala @@ -161,11 +159,11 @@ sort(yss)(xs: List[Int] => list2ordered[Int](xs)(int2ordered)) . The possibility of passing implicit arguments to implicit arguments raises the possibility of an infinite recursion. For instance, one -might try to define the following method, which injects _every_ type into the +might try to define the following method, which injects _every_ type into the `Ordered` class: ```scala -implicit def magic[A](x: A)(implicit a2ordered: A => Ordered[A]): Ordered[A] = +implicit def magic[A](x: A)(implicit a2ordered: A => Ordered[A]): Ordered[A] = a2ordered(x) ``` @@ -178,7 +176,7 @@ expansion: sort(arg)(x => magic(x)(x => magic(x)(x => ... ))) ``` -To prevent such infinite expansions, the compiler keeps track of +To prevent such infinite expansions, the compiler keeps track of a stack of “open implicit types” for which implicit arguments are currently being searched. Whenever an implicit argument for type $T$ is searched, the “core type” of $T$ is added to the stack. Here, the _core type_ @@ -190,7 +188,7 @@ the implicit argument either definitely fails or succeeds. Everytime a core type is added to the stack, it is checked that this type does not dominate any of the other types in the set. -Here, a core type $T$ _dominates_ a type $U$ if $T$ is +Here, a core type $T$ _dominates_ a type $U$ if $T$ is [equivalent](03-types.html#type-equivalence) to $U$, or if the top-level type constructors of $T$ and $U$ have a common element and $T$ is more complex than $U$. @@ -212,7 +210,6 @@ the type: - For any other singleton type, $\operatorname{complexity}(p.type) ~=~ 1 + \operatorname{complexity}(T)$, provided $p$ has type $T$; - For a compound type, `$\operatorname{complexity}(T_1$ with $\ldots$ with $T_n)$` $= \Sigma\operatorname{complexity}(T_i)$ - ###### Example When typing `sort(xs)` for some list `xs` of type `List[List[List[Int]]]`, the sequence of types for @@ -228,7 +225,6 @@ All types share the common type constructor `scala.Function1`, but the complexity of the each new type is lower than the complexity of the previous types. Hence, the code typechecks. - ###### Example Let `ys` be a list of some type which cannot be converted to `Ordered`. For instance: @@ -249,7 +245,6 @@ Throwable => Ordered[Throwable], Since the second type in the sequence is equal to the first, the compiler will issue an error signalling a divergent implicit expansion. - ## Views Implicit parameters and methods can also define implicit conversions @@ -266,7 +261,7 @@ Views are applied in three situations: $\mathit{pt}$. The search proceeds as in the case of implicit parameters, where the implicit scope is the one of `$T$ => $\mathit{pt}$`. If such a view is found, the expression $e$ is converted to - `$v$($e$)`. + `$v$($e$)`. 1. In a selection $e.m$ with $e$ of type $T$, if the selector $m$ does not denote an accessible member of $T$. In this case, a view $v$ is searched which is applicable to $e$ and whose result contains a member named @@ -275,13 +270,12 @@ Views are applied in three situations: selection $e.m$ is converted to `$v$($e$).$m$`. 1. In a selection $e.m(\mathit{args})$ with $e$ of type $T$, if the selector $m$ denotes some member(s) of $T$, but none of these members is applicable to the arguments - $\mathit{args}$. In this case a view $v$ is searched which is applicable to $e$ + $\mathit{args}$. In this case a view $v$ is searched which is applicable to $e$ and whose result contains a method $m$ which is applicable to $\mathit{args}$. The search proceeds as in the case of implicit parameters, where the implicit scope is the one of $T$. If such a view is found, the selection $e.m$ is converted to `$v$($e$).$m(\mathit{args})$`. - The implicit view, if it is found, can accept is argument $e$ as a call-by-value or as a call-by-name parameter. However, call-by-value implicits take precedence over call-by-name implicits. @@ -319,17 +313,16 @@ The first application of `list2ordered` converts the list occurrence is part of an implicit parameter passed to the `<=` method. - ## Context Bounds and View Bounds ```ebnf - TypeParam ::= (id | ‘_’) [TypeParamClause] [‘>:’ Type] [‘<:’ Type] + TypeParam ::= (id | ‘_’) [TypeParamClause] [‘>:’ Type] [‘<:’ Type] {‘<%’ Type} {‘:’ Type} ``` A type parameter $A$ of a method or non-trait class may have one or more view bounds `$A$ <% $T$`. In this case the type parameter may be -instantiated to any type $S$ which is convertible by application of a +instantiated to any type $S$ which is convertible by application of a view to the bound $T$. A type parameter $A$ of a method or non-trait class may also have one @@ -375,10 +368,9 @@ def <= [B >: A <% Ordered[B]](that: B): Boolean ## Manifests - Manifests are type descriptors that can be automatically generated by the Scala compiler as arguments to implicit parameters. The Scala -standard library contains a hierarchy of four manifest classes, +standard library contains a hierarchy of four manifest classes, with `OptManifest` at the top. Their signatures follow the outline below. @@ -399,7 +391,7 @@ argument is selected. Otherwise, let $\mathit{Mobj}$ be the companion object `scala.reflect.Manifest` if $M$ is trait `Manifest`, or be the companion object `scala.reflect.ClassManifest` otherwise. Let $M'$ be the trait -`Manifest` if $M$ is trait `Manifest`, or be the trait `OptManifest` otherwise. +`Manifest` if $M$ is trait `Manifest`, or be the trait `OptManifest` otherwise. Then the following rules apply. 1. If $T$ is a value class or one of the classes `Any`, `AnyVal`, `Object`, @@ -416,26 +408,25 @@ Then the following rules apply. where $m_0$ is the manifest determined for $M'[S]$ and $ms$ are the manifests determined for $M'[U_1], \ldots, M'[U_n]$. 1. If $T$ is some other class type with type arguments $U_1 , \ldots , U_n$, - a manifest is generated + a manifest is generated with the invocation `$\mathit{Mobj}$.classType[T](classOf[T], $ms$)` where $ms$ are the manifests determined for $M'[U_1] , \ldots , M'[U_n]$. 1. If $T$ is a singleton type `$p$.type`, a manifest is generated with - the invocation `$\mathit{Mobj}$.singleType[T]($p$)` + the invocation `$\mathit{Mobj}$.singleType[T]($p$)` 1. If $T$ is a refined type $T' \{ R \}$, a manifest is generated for $T'$. (That is, refinements are never reflected in manifests). 1. If $T$ is an intersection type `$T_1$ with $, \ldots ,$ with $T_n$` where $n > 1$, the result depends on whether a full manifest is - to be determined or not. + to be determined or not. If $M$ is trait `Manifest`, then a manifest is generated with the invocation `Manifest.intersectionType[T]($ms$)` where $ms$ are the manifests determined for $M[T_1] , \ldots , M[T_n]$. - Otherwise, if $M$ is trait `ClassManifest`, + Otherwise, if $M$ is trait `ClassManifest`, then a manifest is generated for the [intersection dominator](03-types.html#type-erasure) of the types $T_1 , \ldots , T_n$. 1. If $T$ is some other type, then if $M$ is trait `OptManifest`, a manifest is generated from the designator `scala.reflect.NoManifest`. If $M$ is a type different from `OptManifest`, a static error results. - diff --git a/spec/08-pattern-matching.md b/spec/08-pattern-matching.md index 6f71196b0db4..b23be5bbb65b 100644 --- a/spec/08-pattern-matching.md +++ b/spec/08-pattern-matching.md @@ -15,7 +15,7 @@ chapter: 8 | Pattern2 Pattern2 ::= varid [‘@’ Pattern3] | Pattern3 - Pattern3 ::= SimplePattern + Pattern3 ::= SimplePattern | SimplePattern {id [nl] SimplePattern} SimplePattern ::= ‘_’ | varid @@ -68,18 +68,17 @@ which is treated as if it was a fresh variable on each occurrence. ### Typed Patterns - ```ebnf Pattern1 ::= varid `:' TypePat | `_' `:' TypePat ``` A typed pattern $x: T$ consists of a pattern variable $x$ and a -type pattern $T$. The type of $x$ is the type pattern $T$, where +type pattern $T$. The type of $x$ is the type pattern $T$, where each type variable and wildcard is replaced by a fresh, unknown type. -This pattern matches any value matched by the [type pattern](#type-patterns) +This pattern matches any value matched by the [type pattern](#type-patterns) $T$; it binds the variable name to -that value. +that value. ### Pattern Binders @@ -87,10 +86,10 @@ that value. Pattern2 ::= varid `@' Pattern3 ``` -A pattern binder `$x$@$p$` consists of a pattern variable $x$ and a +A pattern binder `$x$@$p$` consists of a pattern variable $x$ and a pattern $p$. The type of the variable $x$ is the static type $T$ of the pattern $p$. -This pattern matches any value $v$ matched by the pattern $p$, -provided the run-time type of $v$ is also an instance of $T$, +This pattern matches any value $v$ matched by the pattern $p$, +provided the run-time type of $v$ is also an instance of $T$, and it binds the variable name to that value. ### Literal Patterns @@ -175,7 +174,7 @@ repeated parameter. This is further discussed [here](#pattern-sequences). ``` A tuple pattern `($p_1 , \ldots , p_n$)` is an alias -for the constructor pattern `scala.Tuple$n$($p_1 , \ldots , p_n$)`, +for the constructor pattern `scala.Tuple$n$($p_1 , \ldots , p_n$)`, where $n \geq 2$. The empty tuple `()` is the unique value of type `scala.Unit`. @@ -196,14 +195,14 @@ $x(p_1 , \ldots , p_n)$ if it takes exactly one argument and one of the following applies: * $n=0$ and `unapply`'s result type is `Boolean`. In this case - the extractor pattern matches all values $v$ for which + the extractor pattern matches all values $v$ for which `$x$.unapply($v$)` yields `true`. * $n=1$ and `unapply`'s result type is `Option[$T$]`, for some type $T$. In this case, the (only) argument pattern $p_1$ is typed in turn with expected type $T$. The extractor pattern matches then all values $v$ for which `$x$.unapply($v$)` yields a value of form `Some($v_1$)`, and $p_1$ matches $v_1$. -* $n>1$ and `unapply`'s result type is +* $n>1$ and `unapply`'s result type is `Option[($T_1 , \ldots , T_n$)]`, for some types $T_1 , \ldots , T_n$. In this case, the argument patterns $p_1 , \ldots , p_n$ are typed in turn with expected types $T_1 , \ldots , @@ -250,7 +249,7 @@ First, in a constructor pattern $c(q_1 , \ldots , q_m, p_1 , \ldots , p_n)$, whe Second, in an extractor pattern $x(q_1 , \ldots , q_m, p_1 , \ldots , p_n)$ if the extractor object $x$ does not have an `unapply` method, but it does define an `unapplySeq` method with a result type conforming to `Option[(T_1, ... , T_m, Seq[S])]` (if `m = 0`, the type `Option[Seq[S]]` is also accepted). The expected type for the patterns $p_i$ is $S$. -The last pattern in a pattern sequence may be a _sequence wildcard_ `_*`. +The last pattern in a pattern sequence may be a _sequence wildcard_ `_*`. Each element pattern $p_i$ is type-checked with $S$ as expected type, unless it is a sequence wildcard. If a final sequence wildcard is present, the pattern matches all values $v$ that @@ -268,7 +267,7 @@ p_n$. An infix operation pattern $p;\mathit{op};q$ is a shorthand for the constructor or extractor pattern $\mathit{op}(p, q)$. The precedence and -associativity of operators in patterns is the same as in +associativity of operators in patterns is the same as in [expressions](06-expressions.html#prefix-infix-and-postfix-operations). An infix operation pattern $p;\mathit{op};(q_1 , \ldots , q_n)$ is a @@ -284,7 +283,7 @@ shorthand for the constructor or extractor pattern $\mathit{op}(p, q_1 A pattern alternative `$p_1$ | $\ldots$ | $p_n$` consists of a number of alternative patterns $p_i$. All alternative patterns are type checked with the expected type of the pattern. They -may no bind variables other than wildcards. The alternative pattern +may no bind variables other than wildcards. The alternative pattern matches a value $v$ if at least one its alternatives matches $v$. ### XML Patterns @@ -315,7 +314,7 @@ A pattern $p$ is _irrefutable_ for a type $T$, if one of the following applies: 1. $p$ is a typed pattern $x: T'$, and $T <: T'$, 1. $p$ is a constructor pattern $c(p_1 , \ldots , p_n)$, the type $T$ is an instance of class $c$, the [primary constructor](05-classes-and-objects.html#class-definitions) - of type $T$ has argument types $T_1 , \ldots , T_n$, and each $p_i$ is + of type $T$ has argument types $T_1 , \ldots , T_n$, and each $p_i$ is irrefutable for $T_i$. ## Type Patterns @@ -324,18 +323,18 @@ A pattern $p$ is _irrefutable_ for a type $T$, if one of the following applies: TypePat ::= Type ``` -Type patterns consist of types, type variables, and wildcards. +Type patterns consist of types, type variables, and wildcards. A type pattern $T$ is of one of the following forms: * A reference to a class $C$, $p.C$, or `$T$#$C$`. This - type pattern matches any non-null instance of the given class. + type pattern matches any non-null instance of the given class. Note that the prefix of the class, if it is given, is relevant for determining class instances. For instance, the pattern $p.C$ matches only instances of classes $C$ which were created with the path $p$ as prefix. The bottom types `scala.Nothing` and `scala.Null` cannot - be used as type patterns, because they would match nothing in any case. + be used as type patterns, because they would match nothing in any case. * A singleton type `$p$.type`. This type pattern matches only the value denoted by the path $p$ (that is, a pattern match involved a @@ -346,7 +345,7 @@ A type pattern $T$ is of one of the following forms: the type patterns $T_i$. * A parameterized type pattern $T[a_1 , \ldots , a_n]$, where the $a_i$ - are type variable patterns or wildcards `_`. + are type variable patterns or wildcards `_`. This type pattern matches all values which match $T$ for some arbitrary instantiation of the type variables and wildcards. The bounds or alias type of these type variable are determined as @@ -356,8 +355,7 @@ A type pattern $T$ is of one of the following forms: $T_1$ is a type pattern. This type pattern matches any non-null instance of type `scala.Array$[U_1]$`, where $U_1$ is a type matched by $T_1$. - -Types which are not of one of the forms described above are also +Types which are not of one of the forms described above are also accepted as type patterns. However, such type patterns will be translated to their [erasure](03-types.html#type-erasure). The Scala compiler will issue an "unchecked" warning for these patterns to @@ -373,7 +371,6 @@ bound type variables in a typed pattern or constructor pattern. Inference takes into account the expected type of the pattern. - ### Type parameter inference for typed patterns. Assume a typed pattern $p: T'$. Let $T$ result from $T'$ where all wildcards in @@ -386,7 +383,7 @@ the type variables $a_i$. The initial constraints set $\mathcal{C}\_0$ reflects just the bounds of these type variables. That is, assuming $T$ has bound type variables $a_1 , \ldots , a_n$ which correspond to class type parameters $a_1' , \ldots , a_n'$ with lower bounds $L_1, \ldots , L_n$ -and upper bounds $U_1 , \ldots , U_n$, $\mathcal{C}_0$ contains the constraints +and upper bounds $U_1 , \ldots , U_n$, $\mathcal{C}_0$ contains the constraints $$ \begin{cases} @@ -395,7 +392,6 @@ a_i &<: \sigma U_i & \quad (i = 1, \ldots , n) \\\\ \end{cases} $$ - where $\sigma$ is the substitution $[a_1' := a_1 , \ldots , a_n' :=a_n]$. The set $\mathcal{C}_0$ is then augmented by further subtype constraints. There are two @@ -432,7 +428,7 @@ We take $a_i >: L_i <: U_i$ where each $L_i$ is minimal and each $U_i$ is maxima ###### Case 2 We take $a_i >: L_i <: U_i$ and $b\_i >: L_i' <: U_i' $ where each $L_i$ and $L_j'$ is minimal and each $U_i$ and $U_j'$ is maximal such that -$a_i >: L_i <: U_i$ for $i = 1 , \ldots , n$ and +$a_i >: L_i <: U_i$ for $i = 1 , \ldots , n$ and $b_j >: L_j' <: U_j'$ for $j = 1 , \ldots , m$ implies $\mathcal{C}\_0 \wedge \mathcal{C}\_0' \wedge \mathcal{C}_2$. @@ -497,7 +493,6 @@ list `x` contains elements other than strings. The Scala compiler will flag this potential loss of type-safety with an "unchecked" warning message. - ###### Example Consider the program fragment @@ -521,7 +516,6 @@ the case clause as an abstract type with lower and upper bound `y.n`, of type `Int`, is found to conform to the function's declared result type, `Number`. - ## Pattern Matching Expressions ```ebnf @@ -539,12 +533,12 @@ e match { case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ } consists of a selector expression $e$ and a number $n > 0$ of cases. Each case consists of a (possibly guarded) pattern $p_i$ and a block $b_i$. Each $p_i$ might be complemented by a guard -`if $e$` where $e$ is a boolean expression. +`if $e$` where $e$ is a boolean expression. The scope of the pattern variables in $p_i$ comprises the pattern's guard and the corresponding block $b_i$. Let $T$ be the type of the selector expression $e$ and let $a_1 -, \ldots , a_m$ be the type parameters of all methods enclosing +, \ldots , a_m$ be the type parameters of all methods enclosing the pattern matching expression. For every $a_i$, let $L_i$ be its lower bound and $U_i$ be its higher bound. Every pattern $p \in \{p_1, , \ldots , p_n\}$ can be typed in two ways. First, it is attempted @@ -597,7 +591,7 @@ If the selector of a pattern match is an instance of a [`sealed` class](05-classes-and-objects.html#modifiers), the compilation of pattern matching can emit warnings which diagnose that a given set of patterns is not exhaustive, i.e. that there is a -possibility of a `MatchError` being raised at run-time. +possibility of a `MatchError` being raised at run-time. ### Example @@ -639,14 +633,13 @@ Under the assumption `Int <: T <: Int` we can also verify that the type right hand side of the second case, `Int` conforms to its expected type, `T`. - ## Pattern Matching Anonymous Functions ```ebnf BlockExpr ::= `{' CaseClauses `}' ``` -An anonymous function can be defined by a sequence of cases +An anonymous function can be defined by a sequence of cases ```scala { case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ } @@ -663,8 +656,8 @@ If the expected type is `scala.Function$k$[$S_1 , \ldots , S_k$, $R$]`, the expression is taken to be equivalent to the anonymous function: ```scala -($x_1: S_1 , \ldots , x_k: S_k$) => ($x_1 , \ldots , x_k$) match { - case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ +($x_1: S_1 , \ldots , x_k: S_k$) => ($x_1 , \ldots , x_k$) match { + case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ } ``` @@ -721,4 +714,3 @@ anonymous function: case (a, (b, c)) => a + b * c } ``` - diff --git a/spec/09-top-level-definitions.md b/spec/09-top-level-definitions.md index b9c78b23a162..847fab548d7f 100644 --- a/spec/09-top-level-definitions.md +++ b/spec/09-top-level-definitions.md @@ -23,7 +23,7 @@ A compilation unit consists of a sequence of packagings, import clauses, and class and object definitions, which may be preceded by a package clause. -A compilation unit +A compilation unit ```scala package $p_1$; @@ -34,7 +34,7 @@ $\mathit{stats}$ starting with one or more package clauses is equivalent to a compilation unit consisting of the -packaging +packaging ```scala package $p_1$ { $\ldots$ @@ -94,7 +94,6 @@ into a special empty package. That package cannot be named and therefore cannot be imported. However, members of the empty package are visible to each other without qualification. - ## Package Objects ```ebnf @@ -113,7 +112,6 @@ there is a name conflict, the behavior of the program is currently undefined. It is expected that this restriction will be lifted in a future version of Scala. - ## Package References ```ebnf @@ -121,12 +119,12 @@ QualId ::= id {‘.’ id} ``` A reference to a package takes the form of a qualified identifier. -Like all other references, package references are relative. That is, +Like all other references, package references are relative. That is, a package reference starting in a name $p$ will be looked up in the closest enclosing scope that defines a member named $p$. The special predefined name `_root_` refers to the -outermost root package which contains all top-level packages. +outermost root package which contains all top-level packages. ###### Example Consider the following program: @@ -149,7 +147,6 @@ omitted, the name `b` would instead resolve to the package `a.b`, and, provided that package does not also contain a class `B`, a compiler-time error would result. - ## Programs A _program_ is a top-level object that has a member method @@ -161,7 +158,7 @@ passed to the `main` method as a parameter of type The `main` method of a program can be directly defined in the object, or it can be inherited. The scala library defines a special class `scala.App` whose body acts as a `main` method. -An objects $m$ inheriting from this class is thus a program, +An objects $m$ inheriting from this class is thus a program, which executes the initializaton code of the object $m$. ###### Example @@ -198,4 +195,3 @@ object HelloWorld extends App { println("Hello World") } ``` - diff --git a/spec/10-xml-expressions-and-patterns.md b/spec/10-xml-expressions-and-patterns.md index 8d4b45984432..069f499ce9f8 100644 --- a/spec/10-xml-expressions-and-patterns.md +++ b/spec/10-xml-expressions-and-patterns.md @@ -14,7 +14,7 @@ changes being mandated by the possibility of embedding Scala code fragments. ## XML expressions -XML expressions are expressions generated by the following production, where the +XML expressions are expressions generated by the following production, where the opening bracket `<` of the first element must be in a position to start the lexical [XML mode](01-lexical-syntax.html#xml-mode). @@ -29,13 +29,13 @@ related to entity resolution. The following productions describe Scala's extensible markup language, designed as close as possible to the W3C extensible markup language -standard. Only the productions for attribute values and character data are changed. +standard. Only the productions for attribute values and character data are changed. Scala does not support declarations, CDATA sections or processing instructions. Entity references are not resolved at runtime. ```ebnf Element ::= EmptyElemTag - | STag Content ETag + | STag Content ETag EmptyElemTag ::= ‘<’ Name {S Attribute} [S] ‘/>’ @@ -52,17 +52,17 @@ XmlContent ::= Element ``` If an XML expression is a single element, its value is a runtime -representation of an XML node (an instance of a subclass of +representation of an XML node (an instance of a subclass of `scala.xml.Node`). If the XML expression consists of more than one element, then its value is a runtime representation of a -sequence of XML nodes (an instance of a subclass of +sequence of XML nodes (an instance of a subclass of `scala.Seq[scala.xml.Node]`). -If an XML expression is an entity reference, CDATA section, processing -instructions or a comments, it is represented by an instance of the +If an XML expression is an entity reference, CDATA section, processing +instructions or a comments, it is represented by an instance of the corresponding Scala runtime class. -By default, beginning and trailing whitespace in element content is removed, +By default, beginning and trailing whitespace in element content is removed, and consecutive occurrences of whitespace are replaced by a single space character `\u0020`. This behavior can be changed to preserve all whitespace with a compiler option. @@ -76,13 +76,13 @@ AttValue ::= ‘"’ {CharQ | CharRef} ‘"’ ScalaExpr ::= Block -CharData ::= { CharNoRef } $\textit{ without}$ {CharNoRef}`{'CharB {CharNoRef} +CharData ::= { CharNoRef } $\textit{ without}$ {CharNoRef}`{'CharB {CharNoRef} $\textit{ and without}$ {CharNoRef}`]]>'{CharNoRef} ``` XML expressions may contain Scala expressions as attribute values or -within nodes. In the latter case, these are embedded using a single opening +within nodes. In the latter case, these are embedded using a single opening brace `{` and ended by a closing brace `}`. To express a single opening braces within XML text as generated by CharData, it must be doubled. Thus, `{{` represents the XML text `{` and does not introduce an embedded Scala expression. @@ -99,7 +99,7 @@ CharB ::= Char1 $\textit{ without}$ ‘{’ Name ::= XNameStart {NameChar} -XNameStart ::= ‘_’ | BaseChar | Ideographic +XNameStart ::= ‘_’ | BaseChar | Ideographic $\textit{ (as in W3C XML, but without }$ ‘:’$)$ ``` @@ -110,7 +110,7 @@ the opening bracket `<` of the element patterns must be in a position to start the lexical [XML mode](01-lexical-syntax.html#xml-mode). ```ebnf -XmlPattern ::= ElementPattern +XmlPattern ::= ElementPattern ``` Well-formedness constraints of the XML specification apply. @@ -123,18 +123,18 @@ XML patterns may contain [Scala patterns](08-pattern-matching.html#pattern-match Whitespace is treated the same way as in XML expressions. -By default, beginning and trailing whitespace in element content is removed, +By default, beginning and trailing whitespace in element content is removed, and consecutive occurrences of whitespace are replaced by a single space character `\u0020`. This behavior can be changed to preserve all whitespace with a compiler option. ```ebnf ElemPattern ::= EmptyElemTagP - | STagP ContentP ETagP + | STagP ContentP ETagP EmptyElemTagP ::= ‘<’ Name [S] ‘/>’ -STagP ::= ‘<’ Name [S] ‘>’ -ETagP ::= ‘’ +STagP ::= ‘<’ Name [S] ‘>’ +ETagP ::= ‘’ ContentP ::= [CharData] {(ElemPattern|ScalaPatterns) [CharData]} ContentP1 ::= ElemPattern | Reference @@ -144,4 +144,3 @@ ContentP1 ::= ElemPattern | ScalaPatterns ScalaPatterns ::= ‘{’ Patterns ‘}’ ``` - diff --git a/spec/11-user-defined-annotations.md b/spec/11-user-defined-annotations.md index fd7a7f9d3fd9..2c5830c103cb 100644 --- a/spec/11-user-defined-annotations.md +++ b/spec/11-user-defined-annotations.md @@ -14,7 +14,7 @@ chapter: 11 User-defined annotations associate meta-information with definitions. A simple annotation has the form `@$c$` or `@$c(a_1 , \ldots , a_n)$`. Here, $c$ is a constructor of a class $C$, which must conform -to the class `scala.Annotation`. +to the class `scala.Annotation`. Annotations may apply to definitions or declarations, types, or expressions. An annotation of a definition or declaration appears in @@ -122,7 +122,6 @@ Java platform, the following annotations have a standard meaning. When applied to value declarations or definitions that have non-volatile types, the annotation has no effect. - * `@specialized` When applied to the definition of a type parameter, this annotation causes the compiler to generate specialized definitions for primitive types. An optional list of @@ -142,7 +141,6 @@ Java platform, the following annotations have a standard meaning. a definition, the compiler will instead use the specialized version. See the [specialization sid](http://docs.scala-lang.org/sips/completed/scala-specialization.html) for more details of the implementation. - Other annotations may be interpreted by platform- or application-dependent tools. Class `scala.Annotation` has two sub-traits which are used to indicate how these annotations are @@ -163,4 +161,3 @@ mapped to the host environment. In particular, on both the Java and the .NET platforms, such classes must be toplevel; i.e. they may not be contained in another class or object. Additionally, on both Java and .NET, all constructor arguments must be constant expressions. - diff --git a/spec/12-the-scala-standard-library.md b/spec/12-the-scala-standard-library.md index 7ccbe0c9bdc8..2b3ac1742cdd 100644 --- a/spec/12-the-scala-standard-library.md +++ b/spec/12-the-scala-standard-library.md @@ -41,15 +41,15 @@ The signatures of these root classes are described by the following definitions. ```scala -package scala +package scala /** The universal root class */ abstract class Any { /** Defined equality; abstract here */ - def equals(that: Any): Boolean + def equals(that: Any): Boolean /** Semantic equality between values */ - final def == (that: Any): Boolean = + final def == (that: Any): Boolean = if (null eq this) null eq that else this equals that /** Semantic inequality between values */ @@ -73,11 +73,11 @@ abstract class Any { } /** The root class of all value types */ -final class AnyVal extends Any +final class AnyVal extends Any /** The root class of all reference types */ class AnyRef extends Any { - def equals(that: Any): Boolean = this eq that + def equals(that: Any): Boolean = this eq that final def eq(that: AnyRef): Boolean = $\ldots$ // reference equality final def ne(that: AnyRef): Boolean = !(this eq that) @@ -85,7 +85,7 @@ class AnyRef extends Any { def toString: String = $\ldots$ // toString computed from hashCode and class name def synchronized[T](body: => T): T // execute `body` in while locking `this`. -} +} ``` The type test `$x$.isInstanceOf[$T$]` is equivalent to a typed @@ -103,10 +103,9 @@ of the form $D$ or $D[\mathit{tps}]$ where $D$ is a type member of some outer cl In this case $T'$ is `$C$#$D$` (or `$C$#$D[tps]$`, respectively), whereas $T$ itself would expand to `$C$.this.$D[tps]$`. In other words, an `isInstanceOf` test does not check that types have the same enclosing instance. - The test `$x$.asInstanceOf[$T$]` is treated specially if $T$ is a [numeric value type](#value-classes). In this case the cast will -be translated to an application of a [conversion method](#numeric-value-types) +be translated to an application of a [conversion method](#numeric-value-types) `x.to$T$`. For non-numeric values $x$ the operation will raise a `ClassCastException`. @@ -131,19 +130,19 @@ Subrange types, as well as `Int` and `Long` are called _integer types_, whereas Numeric value types are ranked in the following partial order: ```scala -Byte - Short +Byte - Short \ Int - Long - Float - Double - / - Char + / + Char ``` -`Byte` and `Short` are the lowest-ranked types in this order, +`Byte` and `Short` are the lowest-ranked types in this order, whereas `Double` is the highest-ranked. Ranking does _not_ imply a [conformance relationship](03-types.html#conformance); for instance `Int` is not a subtype of `Long`. However, object [`Predef`](#the-predef-object) defines [views](07-implicit-parameters-and-views.html#views) -from every numeric value type to all higher-ranked numeric value types. +from every numeric value type to all higher-ranked numeric value types. Therefore, lower-ranked types are implicitly converted to higher-ranked types when required by the [context](06-expressions.html#implicit-conversions). @@ -182,7 +181,7 @@ Any numeric value type $T$ supports the following methods. numeric value (as when going from `Long` to `Int` or from `Int` to `Byte`) or it might lose precision (as when going from `Double` to `Float` or when converting between - `Long` and `Float`). + `Long` and `Float`). Integer numeric value types support in addition the following operations: @@ -228,7 +227,7 @@ def equals(other: Any): Boolean = other match { ``` The `hashCode` method returns an integer hashcode that maps equal -numeric values to equal results. It is guaranteed to be the identity for +numeric values to equal results. It is guaranteed to be the identity for for type `Int` and for all subrange types. The `toString` method displays its receiver as an integer or @@ -284,7 +283,6 @@ abstract sealed class Int extends AnyVal { } ``` - ### Class `Boolean` Class `Boolean` has only two values: `true` and @@ -292,7 +290,7 @@ Class `Boolean` has only two values: `true` and class definition. ```scala -package scala +package scala abstract sealed class Boolean extends AnyVal { def && (p: => Boolean): Boolean = // boolean and if (this) p else false @@ -316,7 +314,7 @@ and `toString` from class `Any`. The `equals` method returns `true` if the argument is the same boolean value as the receiver, `false` otherwise. The -`hashCode` method returns a fixed, implementation-specific hash-code when invoked on `true`, +`hashCode` method returns a fixed, implementation-specific hash-code when invoked on `true`, and a different, fixed, implementation-specific hash-code when invoked on `false`. The `toString` method returns the receiver converted to a string, i.e. either `"true"` or `"false"`. @@ -328,7 +326,7 @@ from class `Any`. The `equals` method returns `true` if the argument is the unit value `()`, `false` otherwise. The -`hashCode` method returns a fixed, implementation-specific hash-code, +`hashCode` method returns a fixed, implementation-specific hash-code, The `toString` method returns `"()"`. ## Standard Reference Classes @@ -347,7 +345,7 @@ it). For Scala clients the class is taken to support in each case a method ```scala -def + (that: Any): String +def + (that: Any): String ``` which concatenates its left operand with the textual representation of its @@ -359,7 +357,7 @@ Scala defines tuple classes `Tuple$n$` for $n = 2 , \ldots , 22$. These are defined as follows. ```scala -package scala +package scala case class Tuple$n$[+T_1, ..., +T_n](_1: T_1, ..., _$n$: T_$n$) { def toString = "(" ++ _1 ++ "," ++ $\ldots$ ++ "," ++ _$n$ ++ ")" } @@ -375,10 +373,10 @@ Scala defines function classes `Function$n$` for $n = 1 , \ldots , 22$. These are defined as follows. ```scala -package scala +package scala trait Function$n$[-T_1, ..., -T_$n$, +R] { def apply(x_1: T_1, ..., x_$n$: T_$n$): R - def toString = "" + def toString = "" } ``` @@ -391,7 +389,7 @@ class PartialFunction[-A, +B] extends Function1[A, B] { } ``` -The implicitly imported [`Predef`](#the-predef-object) object defines the name +The implicitly imported [`Predef`](#the-predef-object) object defines the name `Function` as an alias of `Function1`. ### Class `Array` @@ -449,8 +447,8 @@ explained in the following. #### Variance Unlike arrays in Java, arrays in Scala are _not_ -co-variant; That is, $S <: T$ does not imply -`Array[$S$] $<:$ Array[$T$]` in Scala. +co-variant; That is, $S <: T$ does not imply +`Array[$S$] $<:$ Array[$T$]` in Scala. However, it is possible to cast an array of $S$ to an array of $T$ if such a cast is permitted in the host environment. @@ -505,7 +503,7 @@ over arrays and additional utility methods: ```scala package scala -object Array { +object Array { /** copies array elements from `src` to `dest`. */ def copy(src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int): Unit = $\ldots$ @@ -557,36 +555,36 @@ object Array { ## Class Node ```scala -package scala.xml +package scala.xml trait Node { /** the label of this node */ - def label: String + def label: String /** attribute axis */ - def attribute: Map[String, String] + def attribute: Map[String, String] /** child axis (all children of this node) */ - def child: Seq[Node] + def child: Seq[Node] /** descendant axis (all descendants of this node) */ - def descendant: Seq[Node] = child.toList.flatMap { - x => x::x.descendant.asInstanceOf[List[Node]] - } + def descendant: Seq[Node] = child.toList.flatMap { + x => x::x.descendant.asInstanceOf[List[Node]] + } /** descendant axis (all descendants of this node) */ - def descendant_or_self: Seq[Node] = this::child.toList.flatMap { - x => x::x.descendant.asInstanceOf[List[Node]] - } + def descendant_or_self: Seq[Node] = this::child.toList.flatMap { + x => x::x.descendant.asInstanceOf[List[Node]] + } override def equals(x: Any): Boolean = x match { - case that:Node => - that.label == this.label && - that.attribute.sameElements(this.attribute) && + case that:Node => + that.label == this.label && + that.attribute.sameElements(this.attribute) && that.child.sameElements(this.child) case _ => false - } + } /** XPath style projection function. Returns all children of this node * that are labeled with 'that'. The document order is preserved. @@ -594,40 +592,39 @@ trait Node { def \(that: Symbol): NodeSeq = { new NodeSeq({ that.name match { - case "_" => child.toList + case "_" => child.toList case _ => - var res:List[Node] = Nil + var res:List[Node] = Nil for (x <- child.elements if x.label == that.name) { - res = x::res + res = x::res } res.reverse } - }) + }) } - /** XPath style projection function. Returns all nodes labeled with the + /** XPath style projection function. Returns all nodes labeled with the * name 'that' from the 'descendant_or_self' axis. Document order is preserved. */ def \\(that: Symbol): NodeSeq = { new NodeSeq( that.name match { - case "_" => this.descendant_or_self + case "_" => this.descendant_or_self case _ => this.descendant_or_self.asInstanceOf[List[Node]]. - filter(x => x.label == that.name) + filter(x => x.label == that.name) }) } /** hashcode for this XML node */ - override def hashCode = - Utility.hashCode(label, attribute.toList.hashCode, child) + override def hashCode = + Utility.hashCode(label, attribute.toList.hashCode, child) /** string representation of this node */ - override def toString = Utility.toXML(this) + override def toString = Utility.toXML(this) } ``` - ## The `Predef` Object The `Predef` object defines standard functions and type aliases @@ -642,7 +639,7 @@ object Predef { // classOf --------------------------------------------------------- /** Returns the runtime representation of a class type. */ - def classOf[T]: Class[T] = null + def classOf[T]: Class[T] = null // this is a dummy, classOf is handled by compiler. // Standard type aliases --------------------------------------------- @@ -651,7 +648,7 @@ object Predef { type Class[T] = java.lang.Class[T] // Miscellaneous ----------------------------------------------------- - + type Function[-A, +B] = Function1[A, B] type Map[A, +B] = collection.immutable.Map[A, B] @@ -668,7 +665,7 @@ object Predef { val ClassManifest = scala.reflect.ClassManifest val Manifest = scala.reflect.Manifest val NoManifest = scala.reflect.NoManifest - + def manifest[T](implicit m: Manifest[T]) = m def classManifest[T](implicit m: ClassManifest[T]) = m def optManifest[T](implicit m: OptManifest[T]) = m @@ -711,7 +708,6 @@ object Predef { } ``` - ```scala // tupling --------------------------------------------------------- @@ -755,13 +751,12 @@ object Predef { } ``` - ### Predefined Implicit Definitions The `Predef` object also contains a number of implicit definitions, which are available by default (because `Predef` is implicitly imported). -Implicit definitions come in two priorities. High-priority implicits are defined in the `Predef` class itself whereas low priority implicits are defined in a class inherited by `Predef`. The rules of +Implicit definitions come in two priorities. High-priority implicits are defined in the `Predef` class itself whereas low priority implicits are defined in a class inherited by `Predef`. The rules of static [overloading resolution](06-expressions.html#overloading-resolution) -stipulate that, all other things being equal, implicit resolution +stipulate that, all other things being equal, implicit resolution prefers high-priority implicits over low-priority ones. The available low-priority implicits include definitions falling into the following categories. @@ -777,13 +772,12 @@ The available low-priority implicits include definitions falling into the follow 1. An implicit conversion from `String` to `WrappedString`. - The available high-priority implicits include definitions falling into the following categories. - * An implicit wrapper that adds `ensuring` methods + * An implicit wrapper that adds `ensuring` methods with the following overloaded variants to type `Any`. - ``` + ``` def ensuring(cond: Boolean): A = { assert(cond); x } def ensuring(cond: Boolean, msg: Any): A = { assert(cond, msg); x } def ensuring(cond: A => Boolean): A = { assert(cond(x)); x } @@ -793,7 +787,7 @@ The available high-priority implicits include definitions falling into the follo * An implicit wrapper that adds a `->` method with the following implementation to type `Any`. - ``` + ``` def -> [B](y: B): (A, B) = (x, y) ``` @@ -807,12 +801,12 @@ The available high-priority implicits include definitions falling into the follo * An implicit wrapper that adds `+` and `formatted` method with the following implementations to type `Any`. - ``` + ``` def +(other: String) = String.valueOf(self) + other def formatted(fmtstr: String): String = fmtstr format self ``` - * Numeric primitive conversions that implement the transitive closure of the + * Numeric primitive conversions that implement the transitive closure of the following mappings: ``` @@ -824,7 +818,7 @@ The available high-priority implicits include definitions falling into the follo Float -> Double ``` - * Boxing and unboxing conversions between primitive types and their boxed + * Boxing and unboxing conversions between primitive types and their boxed versions: ``` @@ -841,9 +835,8 @@ The available high-priority implicits include definitions falling into the follo * An implicit definition that generates instances of type `T <:< T`, for any type `T`. Here, `<:<` is a class defined as follows. - ``` + ``` sealed abstract class <:<[-From, +To] extends (From => To) ``` Implicit parameters of `<:<` types are typically used to implement type constraints. - diff --git a/spec/13-syntax-summary.md b/spec/13-syntax-summary.md index 3eecc26eb417..86efcf70a88e 100644 --- a/spec/13-syntax-summary.md +++ b/spec/13-syntax-summary.md @@ -30,7 +30,7 @@ opchar ::= // printableChar not matched by (whiteSpace | upper | lower printableChar ::= // all characters in [\u0020, \u007F] inclusive charEscapeSeq ::= ‘\‘ (‘b‘ | ‘t‘ | ‘n‘ | ‘f‘ | ‘r‘ | ‘"‘ | ‘'‘ | ‘\‘) -op ::= opchar {opchar} +op ::= opchar {opchar} varid ::= lower idrest plainid ::= upper idrest | varid @@ -45,7 +45,7 @@ hexNumeral ::= ‘0’ ‘x’ hexDigit {hexDigit} digit ::= ‘0’ | nonZeroDigit nonZeroDigit ::= ‘1’ | … | ‘9’ -floatingPointLiteral +floatingPointLiteral ::= digit {digit} ‘.’ digit {digit} [exponentPart] [floatType] | ‘.’ digit {digit} [exponentPart] [floatType] | digit {digit} exponentPart [floatType] @@ -99,7 +99,7 @@ grammar. FunctionArgTypes ::= InfixType | ‘(’ [ ParamType {‘,’ ParamType } ] ‘)’ ExistentialClause ::= ‘forSome’ ‘{’ ExistentialDcl {semi ExistentialDcl} ‘}’ - ExistentialDcl ::= ‘type’ TypeDcl + ExistentialDcl ::= ‘type’ TypeDcl | ‘val’ ValDcl InfixType ::= CompoundType {id [nl] CompoundType} CompoundType ::= AnnotType {‘with’ AnnotType} [Refinement] @@ -119,7 +119,7 @@ grammar. TypePat ::= Type Ascription ::= ‘:’ InfixType - | ‘:’ Annotation {Annotation} + | ‘:’ Annotation {Annotation} | ‘:’ ‘_’ ‘*’ Expr ::= (Bindings | [‘implicit’] id | ‘_’) ‘=>’ Expr @@ -139,7 +139,7 @@ grammar. PostfixExpr ::= InfixExpr [id [nl]] InfixExpr ::= PrefixExpr | InfixExpr id [nl] InfixExpr - PrefixExpr ::= [‘-’ | ‘+’ | ‘~’ | ‘!’] SimpleExpr + PrefixExpr ::= [‘-’ | ‘+’ | ‘~’ | ‘!’] SimpleExpr SimpleExpr ::= ‘new’ (ClassTemplate | TemplateBody) | BlockExpr | SimpleExpr1 [‘_’] @@ -147,7 +147,7 @@ grammar. | Path | ‘_’ | ‘(’ [Exprs] ‘)’ - | SimpleExpr ‘.’ id + | SimpleExpr ‘.’ id | SimpleExpr TypeArgs | SimpleExpr1 ArgumentExprs | XmlExpr @@ -170,7 +170,7 @@ grammar. Generator ::= Pattern1 ‘<-’ Expr {[semi] Guard | semi Pattern1 ‘=’ Expr} CaseClauses ::= CaseClause { CaseClause } - CaseClause ::= ‘case’ Pattern [Guard] ‘=>’ Block + CaseClause ::= ‘case’ Pattern [Guard] ‘=>’ Block Guard ::= ‘if’ PostfixExpr Pattern ::= Pattern1 { ‘|’ Pattern1 } @@ -195,16 +195,16 @@ grammar. TypeParamClause ::= ‘[’ VariantTypeParam {‘,’ VariantTypeParam} ‘]’ FunTypeParamClause::= ‘[’ TypeParam {‘,’ TypeParam} ‘]’ VariantTypeParam ::= {Annotation} [‘+’ | ‘-’] TypeParam - TypeParam ::= (id | ‘_’) [TypeParamClause] [‘>:’ Type] [‘<:’ Type] + TypeParam ::= (id | ‘_’) [TypeParamClause] [‘>:’ Type] [‘<:’ Type] {‘<%’ Type} {‘:’ Type} ParamClauses ::= {ParamClause} [[nl] ‘(’ ‘implicit’ Params ‘)’] ParamClause ::= [nl] ‘(’ [Params] ‘)’ Params ::= Param {‘,’ Param} Param ::= {Annotation} id [‘:’ ParamType] [‘=’ Expr] - ParamType ::= Type - | ‘=>’ Type + ParamType ::= Type + | ‘=>’ Type | Type ‘*’ - ClassParamClauses ::= {ClassParamClause} + ClassParamClauses ::= {ClassParamClause} [[nl] ‘(’ ‘implicit’ ClassParams ‘)’] ClassParamClause ::= [nl] ‘(’ [ClassParams] ‘)’ ClassParams ::= ClassParam {‘,’ ClassParam} @@ -213,7 +213,7 @@ grammar. Bindings ::= ‘(’ Binding {‘,’ Binding ‘)’ Binding ::= (id | ‘_’) [‘:’ Type] - Modifier ::= LocalModifier + Modifier ::= LocalModifier | AccessModifier | ‘override’ LocalModifier ::= ‘abstract’ @@ -234,7 +234,7 @@ grammar. | Expr | SelfType ::= id [‘:’ Type] ‘=>’ - | ‘this’ ‘:’ Type ‘=>’ + | ‘this’ ‘:’ Type ‘=>’ Import ::= ‘import’ ImportExpr {‘,’ ImportExpr} ImportExpr ::= StableId ‘.’ (id | ‘_’ | ImportSelectors) @@ -263,15 +263,15 @@ grammar. | ids ‘:’ Type ‘=’ ‘_’ FunDef ::= FunSig [‘:’ Type] ‘=’ Expr | FunSig [nl] ‘{’ Block ‘}’ - | ‘this’ ParamClause ParamClauses + | ‘this’ ParamClause ParamClauses (‘=’ ConstrExpr | [nl] ConstrBlock) TypeDef ::= id [TypeParamClause] ‘=’ Type TmplDef ::= [‘case’] ‘class’ ClassDef | [‘case’] ‘object’ ObjectDef | ‘trait’ TraitDef - ClassDef ::= id [TypeParamClause] {ConstrAnnotation} [AccessModifier] - ClassParamClauses ClassTemplateOpt + ClassDef ::= id [TypeParamClause] {ConstrAnnotation} [AccessModifier] + ClassParamClauses ClassTemplateOpt TraitDef ::= id [TypeParamClause] TraitTemplateOpt ObjectDef ::= id ClassTemplateOpt ClassTemplateOpt ::= ‘extends’ ClassTemplate | [[‘extends’] TemplateBody] @@ -284,7 +284,7 @@ grammar. EarlyDefs ::= ‘{’ [EarlyDef {semi EarlyDef}] ‘}’ ‘with’ EarlyDef ::= {Annotation [nl]} {Modifier} PatVarDef - ConstrExpr ::= SelfInvocation + ConstrExpr ::= SelfInvocation | ConstrBlock ConstrBlock ::= ‘{’ SelfInvocation {semi BlockStat} ‘}’ SelfInvocation ::= ‘this’ ArgumentExprs {ArgumentExprs} @@ -294,7 +294,7 @@ grammar. | Import | Packaging | PackageObject - | + | Packaging ::= ‘package’ QualId [nl] ‘{’ TopStatSeq ‘}’ PackageObject ::= ‘package’ ‘object’ ObjectDef diff --git a/spec/14-references.md b/spec/14-references.md index 8c169b9ea4a3..caae5796b248 100644 --- a/spec/14-references.md +++ b/spec/14-references.md @@ -4,7 +4,6 @@ layout: default chapter: 14 --- - # References TODO (see comments in markdown source) @@ -49,7 +48,6 @@ for syntactic definitions?", month = nov } - %% Book %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -116,7 +114,6 @@ for syntactic definitions?", OPTannote = {} } - %% InProceedings %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -131,7 +128,6 @@ for syntactic definitions?", \verb@http://www.cis.upenn.edu/~bcpierce/FOOL/FOOL10.html@} } - %% Misc %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% @@ -208,6 +204,4 @@ for syntactic definitions?", short = {http://www.cis.upenn.edu/~bcpierce/papers/variance.pdf} } - - ---> \ No newline at end of file +--> diff --git a/spec/README.md b/spec/README.md index 4bba86febab4..97c3fdf83286 100644 --- a/spec/README.md +++ b/spec/README.md @@ -12,19 +12,17 @@ We use redcarpet 3.1 and jekyll 2 (currently in alpha) to generate the html. Ess ## Building -Travis CI builds the spec automatically on every commit to master and publishes to http://www.scala-lang.org/files/archive/spec/2.11/. +Travis CI builds the spec automatically on every commit to master and publishes to http://www.scala-lang.org/files/archive/spec/2.11/. To preview locally, run `bundle exec jekyll serve -d build/spec/ -s spec/ -w --baseurl=""` (in the root of your checkout of scala/scala), and open http://0.0.0.0:4000/. Jekyll will rebuild as you edit the markdown, but make sure to restart it when you change `_config.yml`. - ## General Advice for editors - All files must be saved as UTF-8: ensure your editors are configured appropriately. - Use of the appropriate unicode characters instead of the latex modifiers for accents, etc. is necessary. For example, é instead of `\'e`. - MathJAX errors will appear within the rendered DOM as span elements with class `mtext` and style attribute `color: red` applied. It is possible to search for this combination in the development tools of the browser of your choice. In chrome, CTRL+F / CMD+F within the inspect element panel allows you to do this. - ### Macro replacements: - While MathJAX just support LaTeX style command definition, it is recommended to not use this as it will likely cause issues with preparing the document for PDF or ebook distribution. @@ -36,7 +34,6 @@ and open http://0.0.0.0:4000/. Jekyll will rebuild as you edit the markdown, but - The macro \commadots can be replaced with ` , … , `. - There is no adequate replacement for `\textsc{...}` (small caps) in pandoc markdown. While unicode contains a number of small capital letters, it is notably missing Q and X as these glyphs are intended for phonetic spelling, therefore these cannot be reliably used. For now, the best option is to use underscore emphasis and capitalise the text manually, `_LIKE THIS_`. - ### Unicode Character replacements - The unicode left and right single quotation marks (‘ and ’) have been used in place of ` and ', where the quotation marks are intended to be paired. These can be typed on a mac using Option+] for a left quote and Option+Shift+] for the right quote. diff --git a/spec/index.md b/spec/index.md index b47cb033cbe9..3815265ad556 100644 --- a/spec/index.md +++ b/spec/index.md @@ -25,7 +25,6 @@ layout: toc {% endfor %}
      - ## Preface Scala is a Java-like programming language which unifies @@ -68,4 +67,3 @@ the language through lively and inspiring discussions and comments on previous versions of this document. The contributors to the Scala mailing list have also given very useful feedback that helped us improve the language and its tools. - From d24ad908451e42925fe6be9995235bf2b4de1b39 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Mon, 15 Sep 2014 14:08:17 +0200 Subject: [PATCH 552/826] spec: fix broken links and anchors, including examples For examples, the "name" of the example (like "Example Ordered") is only used to derived its html id so that one can link to it (see `layouts/default.yml`). Ideally all examples should have a name; here I only added enough to satisfy existing links. --- spec/01-lexical-syntax.md | 6 +++--- spec/03-types.md | 6 +++--- spec/05-classes-and-objects.md | 3 ++- spec/06-expressions.md | 8 ++++---- spec/07-implicit-parameters-and-views.md | 6 +++--- spec/08-pattern-matching.md | 2 +- 6 files changed, 16 insertions(+), 15 deletions(-) diff --git a/spec/01-lexical-syntax.md b/spec/01-lexical-syntax.md index 4bfef79ac5cd..d5752bbdf080 100644 --- a/spec/01-lexical-syntax.md +++ b/spec/01-lexical-syntax.md @@ -178,7 +178,7 @@ between the two tokens. However, if two tokens are separated by at least one completely blank line (i.e a line which contains no printable characters), then two `nl` tokens are inserted. -The Scala grammar (given in full [here](#scala-syntax-summary)) +The Scala grammar (given in full [here](13-syntax-summary.html)) contains productions where optional `nl` tokens, but not semicolons, are accepted. This has the effect that a newline in one of these positions does not terminate an expression or statement. These positions can @@ -202,7 +202,7 @@ A single new line token is accepted - in front of an opening brace ‘{’, if that brace is a legal continuation of the current statement or expression, -- after an [infix operator](06-expressions.html#prefix-infix-and-postfix-operations), +- after an [infix operator](06-expressions.html#prefix,-infix,-and-postfix-operations), if the first token on the next line can start an expression, - in front of a [parameter clause](04-basic-declarations-and-definitions.html#function-declarations-and-definitions), and - after an [annotation](11-user-defined-annotations.html#user-defined-annotations). @@ -498,7 +498,7 @@ lines. ``` Method `stripMargin` is defined in class -[scala.collection.immutable.StringLike](http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.StringLike). +[scala.collection.immutable.StringLike](http://www.scala-lang.org/api/current/#scala.collection.immutable.StringLike). Because there is a predefined [implicit conversion](06-expressions.html#implicit-conversions) from `String` to `StringLike`, the method is applicable to all strings. diff --git a/spec/03-types.md b/spec/03-types.md index 5cfb85e1fcb8..80200cdf33a4 100644 --- a/spec/03-types.md +++ b/spec/03-types.md @@ -178,7 +178,7 @@ well-formed if each actual type parameter _conforms to its bounds_, i.e. $\sigma L_i <: T_i <: \sigma U_i$ where $\sigma$ is the substitution $[ a_1 := T_1 , \ldots , a_n := T_n ]$. -### Example +### Example Parameterized Types Given the partial type definitions: ```scala @@ -204,7 +204,7 @@ G[S, String] ### Example -Given the [above type definitions](example-parameterized-types), +Given the [above type definitions](#example-parameterized-types), the following types are ill-formed: ```scala @@ -349,7 +349,7 @@ $T_2$. The type is equivalent to the type application arbitrary identifier. All type infix operators have the same precedence; parentheses have to -be used for grouping. The [associativity](06-expressions.html#prefix-infix-and-postfix-operations) +be used for grouping. The [associativity](06-expressions.html#prefix,-infix,-and-postfix-operations) of a type operator is determined as for term operators: type operators ending in a colon ‘:’ are right-associative; all other operators are left-associative. diff --git a/spec/05-classes-and-objects.md b/spec/05-classes-and-objects.md index 6ac4c8fdcfc2..ef854b2abb7a 100644 --- a/spec/05-classes-and-objects.md +++ b/spec/05-classes-and-objects.md @@ -220,7 +220,7 @@ Then the linearization of class `Iter` is Note that the linearization of a class refines the inheritance relation: if $C$ is a subclass of $D$, then $C$ precedes $D$ in any linearization where both $C$ and $D$ occur. -[Linearization](#definition-linearization) also satisfies the property that +[Linearization](#definition:-linearization) also satisfies the property that a linearization of a class always contains the linearization of its direct superclass as a suffix. For instance, the linearization of `StringIterator` is @@ -753,6 +753,7 @@ val c = new C(1, "abc", List()) c.z = c.y :: c.z ``` +### Example Private Constructor The following class can be created only from its companion module. ```scala diff --git a/spec/06-expressions.md b/spec/06-expressions.md index 96a2558e61e2..e1f8580313d6 100644 --- a/spec/06-expressions.md +++ b/spec/06-expressions.md @@ -108,11 +108,11 @@ A designator refers to a named term. It can be a _simple name_ or a _selection_. A simple name $x$ refers to a value as specified -[here](02-identifiers-names-and-scopes.html#identifiers-names-and-scopes). +[here](02-identifiers-names-and-scopes.html#identifiers,-names-and-scopes). If $x$ is bound by a definition or declaration in an enclosing class or object $C$, it is taken to be equivalent to the selection `$C$.this.$x$` where $C$ is taken to refer to the class containing $x$ -even if the type name $C$ is [shadowed](02-identifiers-names-and-scopes.html#identifiers-names-and-scopes) at the +even if the type name $C$ is [shadowed](02-identifiers-names-and-scopes.html#identifiers,-names-and-scopes) at the occurrence of $x$. If $r$ is a [stable identifier](03-types.html#paths) of type $T$, the selection $r.x$ refers @@ -802,7 +802,7 @@ Here are some assignment expressions and their equivalent expansions. |`x.f(i) = e` | `x.f.update(i, e)` | |`x.f(i, j) = e` | `x.f.update(i, j, e)`| -### Example +### Example Imperative Matrix Multiplication Here is the usual imperative code for matrix multiplication. @@ -1115,7 +1115,7 @@ Expr1 ::= `try' `{' Block `}' [`catch' `{' CaseClauses `}'] A try expression is of the form `try { $b$ } catch $h$` where the handler $h$ is a -[pattern matching anonymous function](#pattern-matching-anonymous-functions) +[pattern matching anonymous function](08-pattern-matching.html#pattern-matching-anonymous-functions) ```scala { case $p_1$ => $b_1$ $\ldots$ case $p_n$ => $b_n$ } diff --git a/spec/07-implicit-parameters-and-views.md b/spec/07-implicit-parameters-and-views.md index 3a215e74fcc7..27a50cf0586d 100644 --- a/spec/07-implicit-parameters-and-views.md +++ b/spec/07-implicit-parameters-and-views.md @@ -19,7 +19,7 @@ and can be used as implicit conversions called [views](#views). The `implicit` modifier is illegal for all type members, as well as for [top-level objects](09-top-level-definitions.html#packagings). -### Example +### Example Monoid The following code defines an abstract class of monoids and two concrete implementations, `StringMonoid` and `IntMonoid`. The two implementations are marked implicit. @@ -189,7 +189,7 @@ core type is added to the stack, it is checked that this type does not dominate any of the other types in the set. Here, a core type $T$ _dominates_ a type $U$ if $T$ is -[equivalent](03-types.html#type-equivalence) +[equivalent](03-types.html#equivalence) to $U$, or if the top-level type constructors of $T$ and $U$ have a common element and $T$ is more complex than $U$. @@ -284,7 +284,7 @@ As for implicit parameters, overloading resolution is applied if there are several possible candidates (of either the call-by-value or the call-by-name category). -### Example +### Example Ordered Class `scala.Ordered[A]` contains a method ```scala diff --git a/spec/08-pattern-matching.md b/spec/08-pattern-matching.md index b23be5bbb65b..8e224de8d277 100644 --- a/spec/08-pattern-matching.md +++ b/spec/08-pattern-matching.md @@ -268,7 +268,7 @@ p_n$. An infix operation pattern $p;\mathit{op};q$ is a shorthand for the constructor or extractor pattern $\mathit{op}(p, q)$. The precedence and associativity of operators in patterns is the same as in -[expressions](06-expressions.html#prefix-infix-and-postfix-operations). +[expressions](06-expressions.html#prefix,-infix,-and-postfix-operations). An infix operation pattern $p;\mathit{op};(q_1 , \ldots , q_n)$ is a shorthand for the constructor or extractor pattern $\mathit{op}(p, q_1 From 7c81959d724a6565c00b86591d54c195d8bed1de Mon Sep 17 00:00:00 2001 From: ghik Date: Wed, 17 Sep 2014 20:45:01 +0200 Subject: [PATCH 553/826] SI-8459 fix incorrect positions for incomplete selection trees The mentioned issue is a presentation compiler issue, but its root cause is a bug in the parser which incorrectly assigned positions to incomplete selection trees (i.e. selections that lack an indentifier after dot and have some whitespace instead). In detail: for such incomplete selection trees, the "point" of the position should be immediately after the dot but instead was at the start of next token after the dot. For range positions, this caused a pathological situation where the "point" was greater than the "end" of the position. This position is later used by the typechecker during resolution of dynamic calls and causes it to crash. Of course, because a syntactically incorrect code is required for the bug to manifest, it only happens in the presentation compiler. --- .../scala/tools/nsc/ast/parser/Parsers.scala | 2 +- test/files/presentation/t8459.check | 14 ++++++++++++++ test/files/presentation/t8459/Test.scala | 3 +++ .../t8459/src/IncompleteDynamicSelect.scala | 14 ++++++++++++++ 4 files changed, 32 insertions(+), 1 deletion(-) create mode 100644 test/files/presentation/t8459.check create mode 100644 test/files/presentation/t8459/Test.scala create mode 100644 test/files/presentation/t8459/src/IncompleteDynamicSelect.scala diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala index 8d810d456e60..15d6a4d1b4c1 100644 --- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala +++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala @@ -1059,7 +1059,7 @@ self => def identOrMacro(): Name = if (isMacro) rawIdent() else ident() def selector(t: Tree): Tree = { - val point = in.offset + val point = if(isIdent) in.offset else in.lastOffset //SI-8459 //assert(t.pos.isDefined, t) if (t != EmptyTree) Select(t, ident(skipIt = false)) setPos r2p(t.pos.start, point, in.lastOffset) diff --git a/test/files/presentation/t8459.check b/test/files/presentation/t8459.check new file mode 100644 index 000000000000..336c14714105 --- /dev/null +++ b/test/files/presentation/t8459.check @@ -0,0 +1,14 @@ +reload: IncompleteDynamicSelect.scala + +askType at IncompleteDynamicSelect.scala(12,2) +================================================================================ +[response] askTypeAt (12,2) +scala.AnyRef { + def (): Foo = { + Foo.super.(); + () + }; + private[this] val bar: F = new F(); + Foo.this.bar.("") +} +================================================================================ diff --git a/test/files/presentation/t8459/Test.scala b/test/files/presentation/t8459/Test.scala new file mode 100644 index 000000000000..bec1131c4cc1 --- /dev/null +++ b/test/files/presentation/t8459/Test.scala @@ -0,0 +1,3 @@ +import scala.tools.nsc.interactive.tests.InteractiveTest + +object Test extends InteractiveTest \ No newline at end of file diff --git a/test/files/presentation/t8459/src/IncompleteDynamicSelect.scala b/test/files/presentation/t8459/src/IncompleteDynamicSelect.scala new file mode 100644 index 000000000000..61976fe2f9c5 --- /dev/null +++ b/test/files/presentation/t8459/src/IncompleteDynamicSelect.scala @@ -0,0 +1,14 @@ +import scala.language.dynamics + +class F extends Dynamic { + def applyDynamic(name: String)(args: Any*) = + s"method '$name' called with arguments ${args.mkString("'", "', '", "'")}" +} + +class Foo { + val bar = new F + + bar. //note whitespace after dot + /*?*/ //force typechecking +} + From 17a1abbff6816d0693bb98869cd26c25f695cffa Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Thu, 18 Sep 2014 16:01:57 +1000 Subject: [PATCH 554/826] SI-8852 Support joint compilation of Java interfaces w. statics We had to change the java parser to accomodate this language change in Java 8. The enclosed test does not require JDK8 to run, it only tests JavaParsers. Here is a transcript of my manual testing using Java 8. ``` % tail test/files/run/8852b/{Interface.java,client.scala} ==> test/files/run/8852b/Interface.java <== public interface Interface { public static int staticMethod() { return 42; } } ==> test/files/run/8852b/client.scala <== object Test extends App { assert(Interface.staticMethod() == 42) } // Under separate compilation, statics in interfaces were already working % rm /tmp/*.class 2> /dev/null; javac -d /tmp test/files/run/8852b/Interface.java && scalac-hash v2.11.2 -classpath /tmp -d /tmp test/files/run/8852b/client.scala && scala-hash v2.11.2 -classpath /tmp -nc Test // Under joint compilation, statics in interfaces now work. % rm /tmp/*.class 2> /dev/null; qscalac -d /tmp test/files/run/8852b/{client.scala,Interface.java} && javac -d /tmp test/files/run/8852b/Interface.java && qscala -classpath /tmp -nc Test ``` --- .../scala/tools/nsc/javac/JavaParsers.scala | 5 +-- test/files/run/t8852a.scala | 34 +++++++++++++++++++ 2 files changed, 37 insertions(+), 2 deletions(-) create mode 100644 test/files/run/t8852a.scala diff --git a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala index 37b00aa9a3ed..9433ddcf31c9 100644 --- a/src/compiler/scala/tools/nsc/javac/JavaParsers.scala +++ b/src/compiler/scala/tools/nsc/javac/JavaParsers.scala @@ -488,7 +488,8 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners { val vparams = formalParams() if (!isVoid) rtpt = optArrayBrackets(rtpt) optThrows() - val bodyOk = !inInterface || (mods hasFlag Flags.DEFAULTMETHOD) + val isStatic = mods hasFlag Flags.STATIC + val bodyOk = !inInterface || ((mods hasFlag Flags.DEFAULTMETHOD) || isStatic) val body = if (bodyOk && in.token == LBRACE) { methodBody() @@ -507,7 +508,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners { EmptyTree } } - if (inInterface) mods1 |= Flags.DEFERRED + if (inInterface && !isStatic) mods1 |= Flags.DEFERRED List { atPos(pos) { DefDef(mods1, name.toTermName, tparams, List(vparams), rtpt, body) diff --git a/test/files/run/t8852a.scala b/test/files/run/t8852a.scala new file mode 100644 index 000000000000..cbff8ab75b91 --- /dev/null +++ b/test/files/run/t8852a.scala @@ -0,0 +1,34 @@ +import scala.tools.partest._ + +// Test that static methods in Java interfaces (new in Java 8) +// are callable from jointly compiler Scala code. +object Test extends CompilerTest { + import global._ + + override lazy val units: List[CompilationUnit] = { + // This test itself does not depend on JDK8. + javaCompilationUnits(global)(staticMethodInInterface) ++ + compilationUnits(global)(scalaClient) + } + + private def staticMethodInInterface = """ +public interface Interface { + public static int staticMethod() { + return 42; + } +} + + """ + + private def scalaClient = """ +object Test { + val x: Int = Interface.staticMethod() +} + +class C extends Interface // expect no errors about unimplemented members. + + """ + + // We're only checking we can compile it. + def check(source: String, unit: global.CompilationUnit): Unit = () +} From 92692e6cda4deec9d2fa748fcbe3344a7a4cf947 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Thu, 18 Sep 2014 18:25:36 -0700 Subject: [PATCH 555/826] Particular formatting improvement in the spec Fixes the titularity of the "Overloading resolution" header under 6.26.1 "Value conversions" to match "Type instantiation." Hopefully this makes the link to the actual 6.26.3 overloading resolution section work without further renaming. (Edit: changed the minor heading to say "Static overload resolution", which is sufficiently redundant.) Possibly that is the oftenest-cited section of the entire document. At least on Stack Overflow, if not in Proceedings of the ACM. --- spec/06-expressions.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/spec/06-expressions.md b/spec/06-expressions.md index e1f8580313d6..03b8065f4b2e 100644 --- a/spec/06-expressions.md +++ b/spec/06-expressions.md @@ -1336,7 +1336,7 @@ The following five implicit conversions can be applied to an expression $e$ which has some value type $T$ and which is type-checked with some expected type $\mathit{pt}$. -#### Overloading Resolution +###### Static Overloading Resolution If an expression denotes several possible members of a class, [overloading resolution](#overloading-resolution) is applied to pick a unique member. From 9902ae5eca9ae52410231d42a8c96df9454034f4 Mon Sep 17 00:00:00 2001 From: Brian McKenna Date: Sun, 21 Sep 2014 21:56:56 -0600 Subject: [PATCH 556/826] Color REPL under -Dscala.color We already use -Dscala.color when using -Ytyper-debug This tries to reuse the colors chosen from the debug flag: * Bold blue for vals (e.g. "res0") * Bold green for types (e.g. "Int") * Magenta for the shell prompt (e.g. "scala>") --- src/repl/scala/tools/nsc/interpreter/ILoop.scala | 8 +++++++- .../scala/tools/nsc/interpreter/MemberHandlers.scala | 10 +++++++++- src/repl/scala/tools/nsc/interpreter/ReplProps.scala | 3 +++ 3 files changed, 19 insertions(+), 2 deletions(-) diff --git a/src/repl/scala/tools/nsc/interpreter/ILoop.scala b/src/repl/scala/tools/nsc/interpreter/ILoop.scala index 50c89f7442ea..cfc4e5a5c8cc 100644 --- a/src/repl/scala/tools/nsc/interpreter/ILoop.scala +++ b/src/repl/scala/tools/nsc/interpreter/ILoop.scala @@ -445,8 +445,14 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) } private def readOneLine() = { + import scala.io.AnsiColor.{ MAGENTA, RESET } out.flush() - in readLine prompt + in readLine ( + if (replProps.colorOk) + MAGENTA + prompt + RESET + else + prompt + ) } /** The main read-eval-print loop for the repl. It calls diff --git a/src/repl/scala/tools/nsc/interpreter/MemberHandlers.scala b/src/repl/scala/tools/nsc/interpreter/MemberHandlers.scala index a37cdc2ec84b..8e624174ed7c 100644 --- a/src/repl/scala/tools/nsc/interpreter/MemberHandlers.scala +++ b/src/repl/scala/tools/nsc/interpreter/MemberHandlers.scala @@ -119,7 +119,15 @@ trait MemberHandlers { if (replProps.vids) s"""" + f"@$${System.identityHashCode($path)}%8x" + """" else "" - """ + "%s%s: %s = " + %s""".format(string2code(prettyName), vidString, string2code(req typeOf name), resultString) + import scala.io.AnsiColor.{ BOLD, BLUE, GREEN, RESET } + + def color(c: String, s: String) = + if (replProps.colorOk) string2code(BOLD) + string2code(c) + s + string2code(RESET) + else s + + val nameString = color(BLUE, string2code(prettyName)) + vidString + val typeString = color(GREEN, string2code(req typeOf name)) + s""" + "$nameString: $typeString = " + $resultString""" } } } diff --git a/src/repl/scala/tools/nsc/interpreter/ReplProps.scala b/src/repl/scala/tools/nsc/interpreter/ReplProps.scala index 36e6dbbccc12..8c4faf7278c4 100644 --- a/src/repl/scala/tools/nsc/interpreter/ReplProps.scala +++ b/src/repl/scala/tools/nsc/interpreter/ReplProps.scala @@ -13,6 +13,9 @@ class ReplProps { private def bool(name: String) = BooleanProp.keyExists(name) private def int(name: String) = IntProp(name) + // This property is used in TypeDebugging. Let's recycle it. + val colorOk = bool("scala.color") + val info = bool("scala.repl.info") val debug = bool("scala.repl.debug") val trace = bool("scala.repl.trace") From 252901054e40276abdb734673e41c6ce01adb7cc Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Fri, 12 Sep 2014 08:03:08 -0700 Subject: [PATCH 557/826] SI-6502 Remove cp command as unworkable People expect to change the class path midstream. Let's disabuse them by removing the broken command. The internals are deprecated. --- src/repl/scala/tools/nsc/interpreter/ILoop.scala | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/repl/scala/tools/nsc/interpreter/ILoop.scala b/src/repl/scala/tools/nsc/interpreter/ILoop.scala index 50c89f7442ea..9353d03a087b 100644 --- a/src/repl/scala/tools/nsc/interpreter/ILoop.scala +++ b/src/repl/scala/tools/nsc/interpreter/ILoop.scala @@ -75,6 +75,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) def history = in.history // classpath entries added via :cp + @deprecated("Use reset, replay or require to update class path", since = "2.11") var addedClasspath: String = "" /** A reverse list of commands to replay if the user requests a :replay */ @@ -207,7 +208,6 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) /** Standard commands **/ lazy val standardCommands = List( - cmd("cp", "", "add a jar or directory to the classpath", addClasspath), cmd("edit", "|", "edit history", editCommand), cmd("help", "[command]", "print this summary or command-specific help", helpCommand), historyCommand, @@ -221,6 +221,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) nullary("power", "enable power user mode", powerCmd), nullary("quit", "exit the interpreter", () => Result(keepRunning = false, None)), nullary("replay", "reset execution and replay all previous commands", replay), + //cmd("require", "", "add a jar or directory to the classpath", require), // TODO nullary("reset", "reset the repl to its initial state, forgetting all session entries", resetCommand), cmd("save", "", "save replayable session to a file", saveCommand), shCommand, @@ -482,6 +483,8 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) echo("") } } + /** `reset` the interpreter in an attempt to start fresh. + */ def resetCommand() { echo("Resetting interpreter state.") if (replayCommandStack.nonEmpty) { @@ -619,6 +622,7 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) else File(filename).printlnAll(replayCommands: _*) ) + @deprecated("Use reset, replay or require to update class path", since = "2.11") def addClasspath(arg: String): Unit = { val f = File(arg).normalize if (f.exists) { From e720babdaf999878642c18cebec4c18e93988d54 Mon Sep 17 00:00:00 2001 From: Som Snytt Date: Mon, 15 Sep 2014 23:32:09 -0700 Subject: [PATCH 558/826] SI-6502 Repl reset/replay take settings args The reset and replay commands take arbitrary command line args. When settings args are supplied, the compiler is recreated. For uniformity, the settings command performs only the usual arg parsing: use -flag:true instead of +flag, and clearing a setting is promoted to the command line, so that -Xlint: is not an error but clears the flags. ``` scala> maqicode.Test main null :8: error: not found: value maqicode maqicode.Test main null ^ scala> :reset -classpath/a target/scala-2.11/sample_2.11-1.0.jar Resetting interpreter state. Forgetting all expression results and named terms: $intp scala> maqicode.Test main null Hello, world. scala> val i = 42 i: Int = 42 scala> s"$i is the loneliest numbah." res1: String = 42 is the loneliest numbah. scala> :replay -classpath "" Replaying: maqicode.Test main null Hello, world. Replaying: val i = 42 i: Int = 42 Replaying: s"$i is the loneliest numbah." res1: String = 42 is the loneliest numbah. scala> :replay -classpath/a "" Replaying: maqicode.Test main null :8: error: not found: value maqicode maqicode.Test main null ^ Replaying: val i = 42 i: Int = 42 Replaying: s"$i is the loneliest numbah." res1: String = 42 is the loneliest numbah. ``` Clearing a clearable setting: ``` scala> :reset -Xlint:missing-interpolator Resetting interpreter state. scala> { val i = 42 ; "$i is the loneliest numbah." } :8: warning: possible missing interpolator: detected interpolated identifier `$i` { val i = 42 ; "$i is the loneliest numbah." } ^ res0: String = $i is the loneliest numbah. scala> :reset -Xlint: Resetting interpreter state. Forgetting this session history: { val i = 42 ; "$i is the loneliest numbah." } scala> { val i = 42 ; "$i is the loneliest numbah." } res0: String = $i is the loneliest numbah. ``` --- .../tools/nsc/settings/AbsSettings.scala | 6 +- .../tools/nsc/settings/MutableSettings.scala | 25 +++-- .../scala/tools/nsc/interpreter/ILoop.scala | 101 +++++++----------- .../tools/nsc/interpreter/ReplStrings.scala | 5 +- test/files/run/t4594-repl-settings.scala | 2 +- 5 files changed, 69 insertions(+), 70 deletions(-) diff --git a/src/compiler/scala/tools/nsc/settings/AbsSettings.scala b/src/compiler/scala/tools/nsc/settings/AbsSettings.scala index 4727e6d86737..060a24d8d498 100644 --- a/src/compiler/scala/tools/nsc/settings/AbsSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/AbsSettings.scala @@ -35,7 +35,11 @@ trait AbsSettings extends scala.reflect.internal.settings.AbsSettings { case s: AbsSettings => this.userSetSettings == s.userSetSettings case _ => false } - override def toString() = "Settings {\n%s}\n" format (userSetSettings map (" " + _ + "\n")).mkString + override def toString() = { + val uss = userSetSettings + val indent = if (uss.nonEmpty) " " * 2 else "" + uss.mkString(f"Settings {%n$indent", f"%n$indent", f"%n}%n") + } def toConciseString = userSetSettings.mkString("(", " ", ")") def checkDependencies = diff --git a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala index bbe21477cb9b..23611bb62977 100644 --- a/src/compiler/scala/tools/nsc/settings/MutableSettings.scala +++ b/src/compiler/scala/tools/nsc/settings/MutableSettings.scala @@ -125,14 +125,26 @@ class MutableSettings(val errorFn: String => Unit) case Some(cmd) => setter(cmd)(args) } - // if arg is of form -Xfoo:bar,baz,quux - def parseColonArg(s: String): Option[List[String]] = { - val (p, args) = StringOps.splitWhere(s, _ == ':', doDropIndex = true) getOrElse (return None) - - // any non-Nil return value means failure and we return s unmodified - tryToSetIfExists(p, (args split ",").toList, (s: Setting) => s.tryToSetColon _) + // -Xfoo: clears Clearables + def clearIfExists(cmd: String): Option[List[String]] = lookupSetting(cmd) match { + case Some(c: Clearable) => c.clear() ; Some(Nil) + case Some(s) => s.errorAndValue(s"Missing argument to $cmd", None) + case None => None } + // if arg is of form -Xfoo:bar,baz,quux + // the entire arg is consumed, so return None for failure + // any non-Nil return value means failure and we return s unmodified + def parseColonArg(s: String): Option[List[String]] = + if (s endsWith ":") { + clearIfExists(s.init) + } else { + for { + (p, args) <- StringOps.splitWhere(s, _ == ':', doDropIndex = true) + rest <- tryToSetIfExists(p, (args split ",").toList, (s: Setting) => s.tryToSetColon _) + } yield rest + } + // if arg is of form -Xfoo or -Xfoo bar (name = "-Xfoo") def parseNormalArg(p: String, args: List[String]): Option[List[String]] = tryToSetIfExists(p, args, (s: Setting) => s.tryToSet _) @@ -532,6 +544,7 @@ class MutableSettings(val errorFn: String => Unit) def prepend(s: String) = prependPath.value = join(s, prependPath.value) def append(s: String) = appendPath.value = join(appendPath.value, s) + override def isDefault = super.isDefault && prependPath.isDefault && appendPath.isDefault override def value = join( prependPath.value, super.value, diff --git a/src/repl/scala/tools/nsc/interpreter/ILoop.scala b/src/repl/scala/tools/nsc/interpreter/ILoop.scala index 9353d03a087b..6a3528d1c92d 100644 --- a/src/repl/scala/tools/nsc/interpreter/ILoop.scala +++ b/src/repl/scala/tools/nsc/interpreter/ILoop.scala @@ -220,12 +220,12 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) cmd("paste", "[-raw] [path]", "enter paste mode or paste a file", pasteCommand), nullary("power", "enable power user mode", powerCmd), nullary("quit", "exit the interpreter", () => Result(keepRunning = false, None)), - nullary("replay", "reset execution and replay all previous commands", replay), + cmd("replay", "[options]", "reset the repl and replay all previous commands", replayCommand), //cmd("require", "", "add a jar or directory to the classpath", require), // TODO - nullary("reset", "reset the repl to its initial state, forgetting all session entries", resetCommand), + cmd("reset", "[options]", "reset the repl to its initial state, forgetting all session entries", resetCommand), cmd("save", "", "save replayable session to a file", saveCommand), shCommand, - cmd("settings", "[+|-]", "+enable/-disable flags, set compiler options", changeSettings), + cmd("settings", "", "update compiler options, if possible; see reset", changeSettings), nullary("silent", "disable/enable automatic printing of results", verbosity), cmd("type", "[-v] ", "display the type of an expression without evaluating it", typeCommand), cmd("kind", "[-v] ", "display the kind of expression's type", kindCommand), @@ -305,57 +305,23 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) intp.lastWarnings foreach { case (pos, msg) => intp.reporter.warning(pos, msg) } } - private def changeSettings(args: String): Result = { - def showSettings() = { - for (s <- settings.userSetSettings.toSeq.sorted) echo(s.toString) - } - def updateSettings() = { - // put aside +flag options - val (pluses, rest) = (args split "\\s+").toList partition (_.startsWith("+")) - val tmps = new Settings - val (ok, leftover) = tmps.processArguments(rest, processAll = true) - if (!ok) echo("Bad settings request.") - else if (leftover.nonEmpty) echo("Unprocessed settings.") - else { - // boolean flags set-by-user on tmp copy should be off, not on - val offs = tmps.userSetSettings filter (_.isInstanceOf[Settings#BooleanSetting]) - val (minuses, nonbools) = rest partition (arg => offs exists (_ respondsTo arg)) - // update non-flags - settings.processArguments(nonbools, processAll = true) - // also snag multi-value options for clearing, e.g. -Ylog: and -language: - for { - s <- settings.userSetSettings - if s.isInstanceOf[Settings#MultiStringSetting] || s.isInstanceOf[Settings#PhasesSetting] - if nonbools exists (arg => arg.head == '-' && arg.last == ':' && (s respondsTo arg.init)) - } s match { - case c: Clearable => c.clear() - case _ => - } - def update(bs: Seq[String], name: String=>String, setter: Settings#Setting=>Unit) = { - for (b <- bs) - settings.lookupSetting(name(b)) match { - case Some(s) => - if (s.isInstanceOf[Settings#BooleanSetting]) setter(s) - else echo(s"Not a boolean flag: $b") - case _ => - echo(s"Not an option: $b") - } - } - update(minuses, identity, _.tryToSetFromPropertyValue("false")) // turn off - update(pluses, "-" + _.drop(1), _.tryToSet(Nil)) // turn on - } - } - if (args.isEmpty) showSettings() else updateSettings() + private def changeSettings(line: String): Result = { + def showSettings() = for (s <- settings.userSetSettings.toSeq.sorted) echo(s.toString) + if (line.isEmpty) showSettings() else { updateSettings(line) ; () } + } + private def updateSettings(line: String) = { + val (ok, rest) = settings.processArguments(words(line), processAll = false) + ok && rest.isEmpty } private def javapCommand(line: String): Result = { if (javap == null) - ":javap unavailable, no tools.jar at %s. Set JDK_HOME.".format(jdkHome) + s":javap unavailable, no tools.jar at $jdkHome. Set JDK_HOME." else if (line == "") ":javap [-lcsvp] [path1 path2 ...]" else javap(words(line)) foreach { res => - if (res.isError) return "Failed: " + res.value + if (res.isError) return s"Failed: ${res.value}" else res.show() } } @@ -473,8 +439,16 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) } /** create a new interpreter and replay the given commands */ - def replay() { - reset() + def replayCommand(line: String): Unit = { + def run(destructive: Boolean): Unit = { + if (destructive) createInterpreter() else reset() + replay() + } + if (line.isEmpty) run(destructive = false) + else if (updateSettings(line)) run(destructive = true) + } + /** Announces as it replays. */ + def replay(): Unit = { if (replayCommandStack.isEmpty) echo("Nothing to replay.") else for (cmd <- replayCommands) { @@ -484,22 +458,27 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) } } /** `reset` the interpreter in an attempt to start fresh. + * Supplying settings creates a new compiler. */ - def resetCommand() { - echo("Resetting interpreter state.") - if (replayCommandStack.nonEmpty) { - echo("Forgetting this session history:\n") - replayCommands foreach echo - echo("") - replayCommandStack = Nil + def resetCommand(line: String): Unit = { + def run(destructive: Boolean): Unit = { + echo("Resetting interpreter state.") + if (replayCommandStack.nonEmpty) { + echo("Forgetting this session history:\n") + replayCommands foreach echo + echo("") + replayCommandStack = Nil + } + if (intp.namedDefinedTerms.nonEmpty) + echo("Forgetting all expression results and named terms: " + intp.namedDefinedTerms.mkString(", ")) + if (intp.definedTypes.nonEmpty) + echo("Forgetting defined types: " + intp.definedTypes.mkString(", ")) + if (destructive) createInterpreter() else reset() } - if (intp.namedDefinedTerms.nonEmpty) - echo("Forgetting all expression results and named terms: " + intp.namedDefinedTerms.mkString(", ")) - if (intp.definedTypes.nonEmpty) - echo("Forgetting defined types: " + intp.definedTypes.mkString(", ")) - - reset() + if (line.isEmpty) run(destructive = false) + else if (updateSettings(line)) run(destructive = true) } + /** Resets without announcements. */ def reset() { intp.reset() unleashAndSetPhase() diff --git a/src/repl/scala/tools/nsc/interpreter/ReplStrings.scala b/src/repl/scala/tools/nsc/interpreter/ReplStrings.scala index 43da5c6f1204..1664546cabdb 100644 --- a/src/repl/scala/tools/nsc/interpreter/ReplStrings.scala +++ b/src/repl/scala/tools/nsc/interpreter/ReplStrings.scala @@ -28,5 +28,8 @@ trait ReplStrings { def any2stringOf(x: Any, maxlen: Int) = "scala.runtime.ScalaRunTime.replStringOf(%s, %s)".format(x, maxlen) - def words(s: String) = (s.trim split "\\s+" filterNot (_ == "")).toList + // no escaped or nested quotes + private[this] val inquotes = """(['"])(.*?)\1""".r + def unquoted(s: String) = s match { case inquotes(_, w) => w ; case _ => s } + def words(s: String) = (s.trim split "\\s+" filterNot (_ == "") map unquoted).toList } diff --git a/test/files/run/t4594-repl-settings.scala b/test/files/run/t4594-repl-settings.scala index 4202991607d2..db5dc19866a7 100644 --- a/test/files/run/t4594-repl-settings.scala +++ b/test/files/run/t4594-repl-settings.scala @@ -14,7 +14,7 @@ object Test extends SessionTest { |warning: there was one deprecation warning; re-run with -deprecation for details |a: String | - |scala> :settings +deprecation + |scala> :settings -deprecation | |scala> def b = depp |:8: warning: method depp is deprecated: Please don't do that. From 48caed547f364d7253eafa07839397c762a8796f Mon Sep 17 00:00:00 2001 From: Brian McKenna Date: Sun, 21 Sep 2014 22:12:13 -0600 Subject: [PATCH 559/826] Make compiler.properties fall back to prefixed Previously, if we wanted to override the shell.prompt property, we had to modify compiler.properties in the jar. This change lets us do the following, instead: scala -Dscala.shell.prompt="$(echo -e "\npuffnfresh> ")" All properties previously loaded from compiler.properties now fall back to "scala." in the system properties when not found. --- src/compiler/scala/tools/nsc/Properties.scala | 2 +- src/library/scala/util/Properties.scala | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/compiler/scala/tools/nsc/Properties.scala b/src/compiler/scala/tools/nsc/Properties.scala index 59fefba95493..bec686ec05dd 100644 --- a/src/compiler/scala/tools/nsc/Properties.scala +++ b/src/compiler/scala/tools/nsc/Properties.scala @@ -11,7 +11,7 @@ object Properties extends scala.util.PropertiesTrait { protected def propCategory = "compiler" protected def pickJarBasedOn = classOf[Global] - // settings based on jar properties + // settings based on jar properties, falling back to System prefixed by "scala." def residentPromptString = scalaPropOrElse("resident.prompt", "\nnsc> ") def shellPromptString = scalaPropOrElse("shell.prompt", "\nscala> ") def shellInterruptedString = scalaPropOrElse("shell.interrupted", ":quit\n") diff --git a/src/library/scala/util/Properties.scala b/src/library/scala/util/Properties.scala index 8835730d9571..367488f11694 100644 --- a/src/library/scala/util/Properties.scala +++ b/src/library/scala/util/Properties.scala @@ -62,10 +62,10 @@ private[scala] trait PropertiesTrait { def envOrSome(name: String, alt: Option[String]) = envOrNone(name) orElse alt - // for values based on propFilename - def scalaPropOrElse(name: String, alt: String): String = scalaProps.getProperty(name, alt) + // for values based on propFilename, falling back to System properties + def scalaPropOrElse(name: String, alt: String): String = scalaPropOrNone(name).getOrElse(alt) def scalaPropOrEmpty(name: String): String = scalaPropOrElse(name, "") - def scalaPropOrNone(name: String): Option[String] = Option(scalaProps.getProperty(name)) + def scalaPropOrNone(name: String): Option[String] = Option(scalaProps.getProperty(name)).orElse(propOrNone("scala." + name)) /** The numeric portion of the runtime Scala version, if this is a final * release. If for instance the versionString says "version 2.9.0.final", From 3a72a9d1109e995b9c4de70f260ac3b5ac8f73b9 Mon Sep 17 00:00:00 2001 From: Antoine Gourlay Date: Mon, 22 Sep 2014 14:29:32 +0200 Subject: [PATCH 560/826] spec: generated TOC with linkable headers This adds a table of contents to the spec, with a way to get the link of a header on hover (like on GitHub) and a "return to top" small icon at the end of each section. Jekyll generates the H1-level table of contents, and then the current one is expended using jQuery all the way down to H5 titles. Examples and H6 headers are ignored. GitHub's (MIT licensed) octicons are used for nice "link" and "up" icons. --- spec/_layouts/default.yml | 32 +++- spec/public/octicons/LICENSE.txt | 9 ++ spec/public/octicons/octicons.css | 235 +++++++++++++++++++++++++++++ spec/public/octicons/octicons.eot | Bin 0 -> 31440 bytes spec/public/octicons/octicons.svg | 198 ++++++++++++++++++++++++ spec/public/octicons/octicons.ttf | Bin 0 -> 31272 bytes spec/public/octicons/octicons.woff | Bin 0 -> 17492 bytes spec/public/scripts/navigation.js | 70 +++++++++ spec/public/stylesheets/screen.css | 78 +++++++++- 9 files changed, 615 insertions(+), 7 deletions(-) create mode 100644 spec/public/octicons/LICENSE.txt create mode 100644 spec/public/octicons/octicons.css create mode 100644 spec/public/octicons/octicons.eot create mode 100644 spec/public/octicons/octicons.svg create mode 100644 spec/public/octicons/octicons.ttf create mode 100644 spec/public/octicons/octicons.woff create mode 100644 spec/public/scripts/navigation.js diff --git a/spec/_layouts/default.yml b/spec/_layouts/default.yml index f78232f461e8..fbbab3a1a06b 100644 --- a/spec/_layouts/default.yml +++ b/spec/_layouts/default.yml @@ -14,7 +14,9 @@ + +