---

yaml
---
r: 341535
b: refs/heads/rxwei-patch-1
c: b6dedb7
h: refs/heads/master
i:
  341533: b040a7d
  341531: 86184c0
  341527: 30e9e32
  341519: 115497e
  341503: efde5ca

Author: slavapestov

[refs]

@@ -1015,7 +1015,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-08-18-a: b10b1fce14385faa6d44f6b933e95
 refs/heads/rdar-43033749-fix-batch-mode-no-diags-swift-5.0-branch: a14e64eaad30de89f0f5f0b2a782eed7ecdcb255
 refs/heads/revert-19006-error-bridging-integer-type: 8a9065a3696535305ea53fe9b71f91cbe6702019
 refs/heads/revert-19050-revert-19006-error-bridging-integer-type: ecf752d54b05dd0a20f510f0bfa54a3fec3bcaca
-refs/heads/rxwei-patch-1: d38a2ea4023f7ed0337ac23f404da8c519fd73d5
+refs/heads/rxwei-patch-1: b6dedb7bb5de0d1480c5217f699d1e1cde5fa379
 refs/heads/shahmishal-patch-1: e58ec0f7488258d42bef51bc3e6d7b3dc74d7b2a
 refs/heads/typelist-existential: 4046359efd541fb5c72d69a92eefc0a784df8f5e
 refs/tags/swift-4.2-DEVELOPMENT-SNAPSHOT-2018-08-20-a: 4319ba09e4fb8650ee86061075c74a016b6baab9

branches/rxwei-patch-1/include/swift/AST/DiagnosticsParse.def

@@ -758,6 +758,10 @@ ERROR(expected_dictionary_value_type,PointsToFirstBadToken,
       "expected dictionary value type", ())
 ERROR(expected_rbracket_dictionary_type,PointsToFirstBadToken,
       "expected ']' in dictionary type", ())
+ERROR(extra_rbracket,PointsToFirstBadToken,
+      "unexpected ']' in type; did you mean to write an array type?", ())
+ERROR(extra_colon,PointsToFirstBadToken,
+      "unexpected ':' in type; did you mean to write a dictionary type?", ())
 
 // Tuple Types
 ERROR(expected_rparen_tuple_type_list,none,

branches/rxwei-patch-1/include/swift/Driver/ToolChain.h

@@ -194,17 +194,23 @@ class ToolChain {
                               file_types::ID InputType,
                               const char *PrefixArgument = nullptr) const;
 
-  /// Get the runtime library link path, which is platform-specific and found
+  /// Get the resource dir link path, which is platform-specific and found
   /// relative to the compiler.
-  void getRuntimeLibraryPath(SmallVectorImpl<char> &runtimeLibPath,
-                             const llvm::opt::ArgList &args, bool shared) const;
+  void getResourceDirPath(SmallVectorImpl<char> &runtimeLibPath,
+                          const llvm::opt::ArgList &args, bool shared) const;
+
+  /// Get the runtime library link paths, which typically include the resource
+  /// dir path and the SDK.
+  void getRuntimeLibraryPaths(SmallVectorImpl<std::string> &runtimeLibPaths,
+                              const llvm::opt::ArgList &args,
+                              StringRef SDKPath, bool shared) const;
 
   void addPathEnvironmentVariableIfNeeded(Job::EnvironmentVector &env,
                                           const char *name,
                                           const char *separator,
                                           options::ID optionID,
                                           const llvm::opt::ArgList &args,
-                                          StringRef extraEntry = "") const;
+                                          ArrayRef<std::string> extraEntries = {}) const;
 
   /// Specific toolchains should override this to provide additional conditions
   /// under which the compiler invocation should be written into debug info. For

branches/rxwei-patch-1/include/swift/Parse/ASTGen.h

@@ -0,0 +1,68 @@
+//===--- ASTGen.h ---------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_PARSE_ASTGEN_H
+#define SWIFT_PARSE_ASTGEN_H
+
+#include "swift/AST/ASTContext.h"
+#include "swift/AST/Expr.h"
+#include "swift/Syntax/SyntaxNodes.h"
+#include "llvm/ADT/DenseMap.h"
+
+namespace swift {
+/// Generates AST nodes from Syntax nodes.
+class ASTGen {
+  ASTContext &Context;
+  // A stack of source locations of syntax constructs. Allows us to get the
+  // SourceLoc necessary to create AST nodes for nodes in not-yet-complete
+  // Syntax tree. The topmost item should always correspond to the token/node
+  // that has been parsed/transformed most recently.
+  // todo [gsoc]: remove when possible
+  llvm::SmallVector<SourceLoc, 16> LocStack;
+
+public:
+  explicit ASTGen(ASTContext &Context) : Context(Context) {}
+
+  IntegerLiteralExpr *generate(syntax::IntegerLiteralExprSyntax &Expr);
+  FloatLiteralExpr *generate(syntax::FloatLiteralExprSyntax &Expr);
+  NilLiteralExpr *generate(syntax::NilLiteralExprSyntax &Expr);
+  BooleanLiteralExpr *generate(syntax::BooleanLiteralExprSyntax &Expr);
+  MagicIdentifierLiteralExpr *generate(syntax::PoundFileExprSyntax &Expr);
+  MagicIdentifierLiteralExpr *generate(syntax::PoundLineExprSyntax &Expr);
+  MagicIdentifierLiteralExpr *generate(syntax::PoundColumnExprSyntax &Expr);
+  MagicIdentifierLiteralExpr *generate(syntax::PoundFunctionExprSyntax &Expr);
+  MagicIdentifierLiteralExpr *generate(syntax::PoundDsohandleExprSyntax &Expr);
+  Expr *generate(syntax::UnknownExprSyntax &Expr);
+
+  /// Stores source location necessary for AST creation.
+  void pushLoc(SourceLoc Loc);
+
+  /// Copy a numeric literal value into AST-owned memory, stripping underscores
+  /// so the semantic part of the value can be parsed by APInt/APFloat parsers.
+  static StringRef copyAndStripUnderscores(StringRef Orig, ASTContext &Context);
+
+private:
+  StringRef copyAndStripUnderscores(StringRef Orig);
+
+  SourceLoc topLoc();
+
+  MagicIdentifierLiteralExpr *
+  generateMagicIdentifierLiteralExpr(const syntax::TokenSyntax &PoundToken);
+
+  /// Map magic literal tokens such as #file to their MagicIdentifierLiteralExpr
+  /// kind.
+  static MagicIdentifierLiteralExpr::Kind
+  getMagicIdentifierLiteralKind(tok Kind);
+};
+} // namespace swift
+
+#endif // SWIFT_PARSE_ASTGEN_H

branches/rxwei-patch-1/include/swift/Parse/HiddenLibSyntaxAction.h

@@ -0,0 +1,71 @@
+//===--- HiddenLibSyntaxAction.h ------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_PARSE_HIDDENLIBSYNTAXACTION_H
+#define SWIFT_PARSE_HIDDENLIBSYNTAXACTION_H
+
+#include "swift/Parse/SyntaxParseActions.h"
+#include "swift/SyntaxParse/SyntaxTreeCreator.h"
+#include "llvm/ADT/DenseMap.h"
+
+namespace swift {
+/// Holds an explicitly provided action and uses it to handle all function
+/// calls. Also hides an implicit SyntaxTreeCreator and ensures libSyntax nodes
+/// are always created. Provides an interface to map results of the explicitly
+/// provided action to the hidden libSyntax action.
+// todo [gsoc]: remove when possible
+class HiddenLibSyntaxAction : public SyntaxParseActions {
+  std::shared_ptr<SyntaxParseActions> ExplicitAction;
+  std::shared_ptr<SyntaxTreeCreator> LibSyntaxAction;
+  llvm::DenseMap<OpaqueSyntaxNode, OpaqueSyntaxNode> OpaqueNodeMap;
+
+  bool areBothLibSyntax() {
+    return ExplicitAction->getOpaqueKind() == OpaqueSyntaxNodeKind::LibSyntax;
+  }
+
+public:
+  HiddenLibSyntaxAction(
+      const std::shared_ptr<SyntaxParseActions> &SPActions,
+      const std::shared_ptr<SyntaxTreeCreator> &LibSyntaxAction)
+      : ExplicitAction(SPActions != nullptr ? SPActions : LibSyntaxAction),
+        LibSyntaxAction(LibSyntaxAction){};
+
+  OpaqueSyntaxNode recordToken(tok tokenKind,
+                               ArrayRef<ParsedTriviaPiece> leadingTrivia,
+                               ArrayRef<ParsedTriviaPiece> trailingTrivia,
+                               CharSourceRange range) override;
+
+  OpaqueSyntaxNode recordMissingToken(tok tokenKind, SourceLoc loc) override;
+
+  OpaqueSyntaxNode recordRawSyntax(syntax::SyntaxKind kind,
+                                   ArrayRef<OpaqueSyntaxNode> elements,
+                                   CharSourceRange range) override;
+
+  std::pair<size_t, OpaqueSyntaxNode>
+  lookupNode(size_t lexerOffset, syntax::SyntaxKind kind) override;
+
+  OpaqueSyntaxNodeKind getOpaqueKind() override {
+    return ExplicitAction->getOpaqueKind();
+  }
+
+  /// Returns the libSyntax node corresponding to the provided node that has
+  /// been created by the explicit action.
+  OpaqueSyntaxNode getLibSyntaxNodeFor(OpaqueSyntaxNode explicitNode);
+
+  /// Returns the underlying libSyntax SyntaxTreeCreator.
+  std::shared_ptr<SyntaxTreeCreator> getLibSyntaxAction() {
+    return LibSyntaxAction;
+  }
+};
+} // namespace swift
+
+#endif // SWIFT_PARSE_HIDDENLIBSYNTAXACTION_H

branches/rxwei-patch-1/include/swift/Parse/LibSyntaxGenerator.h

@@ -0,0 +1,74 @@
+//===----------- LibSyntaxGenerator.h -------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_PARSE_LIBSYNTAXGENERATOR_H
+#define SWIFT_PARSE_LIBSYNTAXGENERATOR_H
+
+#include "swift/Parse/HiddenLibSyntaxAction.h"
+#include "swift/Parse/ParsedRawSyntaxNode.h"
+#include "swift/Parse/ParsedRawSyntaxRecorder.h"
+#include "swift/Parse/SyntaxParsingCache.h"
+#include "swift/Syntax/RawSyntax.h"
+#include "swift/SyntaxParse/SyntaxTreeCreator.h"
+
+namespace swift {
+/// Generates libSyntax nodes either by looking them up using
+/// HiddenLibSyntaxAction (based on provided OpaqueSyntaxNode) or by recording
+/// them with ParsedRawSyntaxRecorder.
+// todo [gsoc]: remove when possible
+class LibSyntaxGenerator {
+  std::shared_ptr<HiddenLibSyntaxAction> Actions;
+  ParsedRawSyntaxRecorder Recorder;
+
+public:
+  explicit LibSyntaxGenerator(std::shared_ptr<HiddenLibSyntaxAction> TwoActions)
+      : Actions(std::move(TwoActions)),
+        Recorder(Actions->getLibSyntaxAction()) {}
+
+  TokenSyntax createToken(ParsedRawSyntaxNode Node) {
+    assert(Node.isDeferredToken());
+
+    auto Kind = Node.getTokenKind();
+    auto Range = Node.getDeferredTokenRangeWithTrivia();
+    auto LeadingTriviaPieces = Node.getDeferredLeadingTriviaPieces();
+    auto TrailingTriviaPieces = Node.getDeferredTrailingTriviaPieces();
+
+    auto Recorded = Recorder.recordToken(Kind, Range, LeadingTriviaPieces,
+                                         TrailingTriviaPieces);
+    auto Raw = static_cast<RawSyntax *>(Recorded.getOpaqueNode());
+    return make<TokenSyntax>(Raw);
+  }
+
+  template <typename SyntaxNode>
+  SyntaxNode createNode(ParsedRawSyntaxNode Node) {
+    assert(Node.isDeferredLayout());
+    auto Kind = Node.getKind();
+    auto Children = Node.getDeferredChildren();
+
+    auto Recorded = Recorder.recordRawSyntax(Kind, Children);
+    auto Raw = static_cast<RawSyntax *>(Recorded.getOpaqueNode());
+    return make<SyntaxNode>(Raw);
+  }
+
+  TokenSyntax getLibSyntaxTokenFor(OpaqueSyntaxNode Node) {
+    return getLibSyntaxNodeFor<TokenSyntax>(Node);
+  }
+
+  template <typename SyntaxNode>
+  SyntaxNode getLibSyntaxNodeFor(OpaqueSyntaxNode Node) {
+    auto Raw = static_cast<RawSyntax *>(Actions->getLibSyntaxNodeFor(Node));
+    return make<SyntaxNode>(Raw);
+  }
+};
+} // namespace swift
+
+#endif // SWIFT_PARSE_LIBSYNTAXGENERATOR_H

branches/rxwei-patch-1/include/swift/Parse/ParsedRawSyntaxNode.h

@@ -156,6 +156,19 @@ class ParsedRawSyntaxNode {
 
   // Deferred Token Data =====================================================//
 
+  CharSourceRange getDeferredTokenRangeWithTrivia() const {
+    assert(DK == DataKind::DeferredToken);
+    auto leadTriviaPieces = getDeferredLeadingTriviaPieces();
+    auto trailTriviaPieces = getDeferredTrailingTriviaPieces();
+
+    auto leadTriviaLen = ParsedTriviaPiece::getTotalLength(leadTriviaPieces);
+    auto trailTriviaLen = ParsedTriviaPiece::getTotalLength(trailTriviaPieces);
+
+    SourceLoc begin = DeferredToken.TokLoc.getAdvancedLoc(-leadTriviaLen);
+    unsigned len = leadTriviaLen + DeferredToken.TokLength + trailTriviaLen;
+
+    return CharSourceRange{begin, len};
+  }
   CharSourceRange getDeferredTokenRangeWithoutBackticks() const {
     assert(DK == DataKind::DeferredToken);
     return CharSourceRange{DeferredToken.TokLoc, DeferredToken.TokLength};

branches/rxwei-patch-1/include/swift/Parse/ParsedSyntaxRecorder.h.gyb

@@ -66,11 +66,31 @@ public:
 
   static Parsed${node.name} makeBlank${node.syntax_kind}(SourceLoc loc,
       SyntaxParsingContext &SPCtx);
+%   elif node.is_unknown():
+private:
+  static Parsed${node.name} record${node.syntax_kind}(
+      ArrayRef<ParsedSyntax> elts,
+      ParsedRawSyntaxRecorder &rec);
+
+public:
+  static Parsed${node.name} defer${node.syntax_kind}(
+      ArrayRef<ParsedSyntax> elts,
+      SyntaxParsingContext &SPCtx);
+
+  static Parsed${node.name} make${node.syntax_kind}(
+      ArrayRef<ParsedSyntax> elts,
+      SyntaxParsingContext &SPCtx);
 %   end
 % end
 
 #pragma mark - Convenience APIs
 
+public:
+  static ParsedTokenSyntax makeToken(const Token &Tok,
+                                     const ParsedTrivia &LeadingTrivia,
+                                     const ParsedTrivia &TrailingTrivia,
+                                     SyntaxParsingContext &SPCtx);
+
   /// Records an unlabelled TupleTypeElementSyntax with the provided type and
   /// optional trailing comma.
   static ParsedTupleTypeElementSyntax

branches/rxwei-patch-1/include/swift/Parse/Parser.h

@@ -25,10 +25,12 @@
 #include "swift/AST/Pattern.h"
 #include "swift/AST/Stmt.h"
 #include "swift/Basic/OptionSet.h"
+#include "swift/Parse/ASTGen.h"
 #include "swift/Parse/Lexer.h"
 #include "swift/Parse/LocalContext.h"
 #include "swift/Parse/PersistentParserState.h"
 #include "swift/Parse/Token.h"
+#include "swift/Parse/ParsedSyntaxNodes.h"
 #include "swift/Parse/ParserPosition.h"
 #include "swift/Parse/ParserResult.h"
 #include "swift/Parse/SyntaxParserResult.h"
@@ -376,6 +378,9 @@ class Parser {
   /// Current syntax parsing context where call backs should be directed to.
   SyntaxParsingContext *SyntaxContext;
 
+  /// The AST generator.
+  ASTGen Generator;
+
 public:
   Parser(unsigned BufferID, SourceFile &SF, DiagnosticEngine* LexerDiags,
          SILParserTUStateBase *SIL,
@@ -518,6 +523,12 @@ class Parser {
     assert(Tok.is(K) && "Consuming wrong token kind");
     return consumeToken();
   }
+  /// Consume a token without providing it to the SyntaxParsingContext.
+  ParsedTokenSyntax consumeTokenSyntax();
+  ParsedTokenSyntax consumeTokenSyntax(tok K) {
+    assert(Tok.is(K) && "Consuming wrong token kind");
+    return consumeTokenSyntax();
+  }
 
   SourceLoc consumeIdentifier(Identifier *Result = nullptr,
                               bool allowDollarIdentifier = false) {
@@ -1324,6 +1335,15 @@ class Parser {
   ParserResult<Expr> parseExprSuper();
   ParserResult<Expr> parseExprStringLiteral();
 
+  // todo [gsoc]: create new result type for ParsedSyntax
+  // todo [gsoc]: turn into proper non-templated methods later
+  template <typename SyntaxNode>
+  ParsedExprSyntax parseExprSyntax();
+
+  // todo [gsoc]: remove when possible
+  template <typename SyntaxNode>
+  ParserResult<Expr> parseExprAST();
+
   StringRef copyAndStripUnderscores(StringRef text);
 
   ParserStatus parseStringSegments(SmallVectorImpl<Lexer::StringSegment> &Segments,

branches/rxwei-patch-1/include/swift/Parse/SyntaxParseActions.h

@@ -33,6 +33,12 @@ namespace syntax {
 
 typedef void *OpaqueSyntaxNode;
 
+// todo [gsoc]: remove when possible
+enum class OpaqueSyntaxNodeKind {
+  SwiftSyntax,
+  LibSyntax,
+};
+
 class SyntaxParseActions {
   virtual void _anchor();
 
@@ -60,6 +66,9 @@ class SyntaxParseActions {
   lookupNode(size_t lexerOffset, syntax::SyntaxKind kind) {
     return std::make_pair(0, nullptr);
   }
+
+  /// Returns what kind of OpaqueSyntaxNode is created by `recordXXX` methods.
+  virtual OpaqueSyntaxNodeKind getOpaqueKind() = 0;
 };
 
 } // end namespace swift