[frontend] Fix use-after-free issue found via ASAN

CMakeLists.txt

@@ -416,6 +416,7 @@ include(AddSwift)
 include(SwiftConfigureSDK)
 include(SwiftComponents)
 include(SwiftList)
+include(AddSwiftRuntime)
 
 # Configure swift include, install, build components.
 swift_configure_components()
@@ -785,6 +786,17 @@ if("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
   set(CMAKE_OSX_DEPLOYMENT_TARGET "")
 endif()
 
+swift_runtime_enable_backtrace_reporting(SWIFT_RUNTIME_ENABLE_BACKTRACE_REPORTING_default)
+set(SWIFT_RUNTIME_ENABLE_BACKTRACE_REPORTING
+    ${SWIFT_RUNTIME_ENABLE_BACKTRACE_REPORTING_default}
+    CACHE BOOL "Enable simple backtrace printing using dladdr")
+set(SWIFT_RUNTIME_DLADDR_ALLOWED
+    ${SWIFT_RUNTIME_ENABLE_BACKTRACE_REPORTING_default}
+    CACHE BOOL "Is dladdr allowed to be used in the code base. Must be TRUE if SWIFT_RUNTIME_ENABLE_BACKTRACE_REPORTING is set to TRUE")
+if ("${SWIFT_RUNTIME_ENABLE_BACKTRACE_REPORTING}" AND NOT "${SWIFT_RUNTIME_DLADDR_ALLOWED}")
+  message(FATAL "Can not enable backtrace reporting without allowing dladdr to be used by the runtime")
+endif()
+
 message(STATUS "Building host Swift tools for ${SWIFT_HOST_VARIANT_SDK} ${SWIFT_HOST_VARIANT_ARCH}")
 message(STATUS "  Build type: ${CMAKE_BUILD_TYPE}")
 message(STATUS "  Assertions: ${LLVM_ENABLE_ASSERTIONS}")
@@ -798,6 +810,8 @@ message(STATUS "")
 
 message(STATUS "Building Swift runtime with:")
 message(STATUS "  Leak Detection Checker Entrypoints: ${SWIFT_RUNTIME_ENABLE_LEAK_CHECKER}")
+message(STATUS "  Backtraces:                         ${SWIFT_RUNTIME_ENABLE_BACKTRACE_REPORTING}")
+message(STATUS "  DLAddr Allowed:                     ${SWIFT_RUNTIME_DLADDR_ALLOWED}")
 message(STATUS "")
 
 #

cmake/modules/AddSwiftRuntime.cmake

@@ -0,0 +1,52 @@
+#===--- AddSwiftRuntime.cmake --------------------------------------------===#
+#
+# This source file is part of the Swift.org open source project
+#
+# Copyright (c) 2014 - 2017 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
+#
+#===----------------------------------------------------------------------===#
+
+include(SwiftUtils)
+
+function(swift_runtime_enable_backtrace_reporting outvar)
+  precondition(outvar "Must have an outvar set")
+
+  # We do not support backtraces on android...
+  is_sdk_requested(ANDROID swift_build_android)
+  if(${swift_build_android})
+    set(${outvar} FALSE PARENT_SCOPE)
+    return()
+  endif()
+
+  # ... or cygwin
+  if ("${CMAKE_SYSTEM_NAME}" STREQUAL "CYGWIN")
+    set(${outvar} FALSE PARENT_SCOPE)
+    return()
+  endif()
+
+  # ... or win32.
+  if (WIN32)
+    set(${outvar} FALSE PARENT_SCOPE)
+    return()
+  endif()
+
+  # If we are not Darwin, but are cygwin, win32, or android we *do* support
+  # runtime backtraces. This is just preserving the current existing
+  # behavior. Arguably this should be an opt in feature always.
+  if (NOT "${CMAKE_SYSTEM_NAME}" STREQUAL Darwin)
+    set(${outvar} TRUE PARENT_SCOPE)
+    return()
+  endif()
+
+  # Otherwise, we have a Darwin build. Enable runtime backtrace reporting only
+  # when compiler assertions are enabled.
+  if ("${SWIFT_STDLIB_ASSERTIONS}")
+    set(${outvar} TRUE PARENT_SCOPE)
+  else()
+    set(${outvar} FALSE PARENT_SCOPE)
+  endif()
+endfunction()

cmake/modules/SwiftSource.cmake

@@ -278,7 +278,7 @@ function(_compile_swift_files
   endif()
 
   if (SWIFTFILE_IS_STDLIB_CORE OR SWIFTFILE_IS_SDK_OVERLAY)
-    list(APPEND swift_flags "-warn-swift3-objc-inference")
+    list(APPEND swift_flags "-warn-swift3-objc-inference-complete")
   endif()
 
   list(APPEND swift_flags ${SWIFT_EXPERIMENTAL_EXTRA_FLAGS})

include/swift/ABI/HeapObject.h

@@ -0,0 +1,22 @@
+//===--- HeapObject.h - ABI constants for heap objects -----------*- C++ *-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 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
+//
+//===----------------------------------------------------------------------===//
+//
+//  Constants used in the layout of heap objects.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __SWIFT_ABI_HEAPOBJECT_H__
+#define __SWIFT_ABI_HEAPOBJECT_H__
+
+#include "../../../stdlib/public/SwiftShims/HeapObject.h"
+
+#endif // __SWIFT_ABI_HEAPOBJECT_H__

include/swift/AST/ASTNode.h

@@ -61,6 +61,9 @@ namespace swift {
     FUNC(Expr)
     FUNC(Decl)
 #undef FUNC
+
+    /// Whether the AST node is implicit.
+    bool isImplicit() const;
   };
 } // namespace swift
 

include/swift/AST/AccessScope.h

@@ -30,6 +30,11 @@ class AccessScope {
 
   static AccessScope getPublic() { return AccessScope(nullptr); }
 
+  /// Check if private access is allowed. This is a lexical scope check in Swift
+  /// 3 mode. In Swift 4 mode, declarations and extensions of the same type will
+  /// also allow access.
+  static bool allowsPrivateAccess(const DeclContext *useDC, const DeclContext *sourceDC);
+
   /// Returns nullptr if access scope is public.
   const DeclContext *getDeclContext() const { return Value.getPointer(); }
 
@@ -48,7 +53,7 @@ class AccessScope {
   /// \see DeclContext::isChildContextOf
   bool isChildOf(AccessScope AS) const {
     if (!isPublic() && !AS.isPublic())
-      return getDeclContext()->isChildContextOf(AS.getDeclContext());
+      return allowsPrivateAccess(getDeclContext(), AS.getDeclContext());
     if (isPublic() && AS.isPublic())
       return false;
     return AS.isPublic();

include/swift/AST/DiagnosticsParse.def

@@ -1176,6 +1176,8 @@ ERROR(expr_keypath_expected_property_or_type,PointsToFirstBadToken,
       "expected property or type name within '#keyPath(...)'", ())
 ERROR(expr_keypath_expected_rparen,PointsToFirstBadToken,
       "expected ')' to complete '#keyPath' expression", ())
+ERROR(expr_keypath_expected_expr,none,
+      "expected expression path in Swift key path",())
 
 // Selector expressions.
 ERROR(expr_selector_expected_lparen,PointsToFirstBadToken,

include/swift/AST/DiagnosticsSema.def

@@ -441,6 +441,10 @@ ERROR(expr_unsupported_objc_key_path_compound_name,none,
       "compound name", ())
 ERROR(expr_keypath_no_keypath_type,none,
       "broken standard library: no 'KeyPath' type found", ())
+ERROR(expr_swift_keypath_invalid_component,none,
+      "invalid component of Swift key path", ())
+ERROR(expr_swift_keypath_not_starting_with_type,none,
+      "a Swift key path must begin with a type", ())
 
 // Selector expressions.
 ERROR(expr_selector_no_objc_runtime,none,
@@ -1542,6 +1546,13 @@ WARNING(witness_unavailable,none,
 
 ERROR(redundant_conformance,none,
       "redundant conformance of %0 to protocol %1", (Type, DeclName))
+WARNING(redundant_conformance_adhoc,none,
+        "conformance of %0 to protocol %1 was already stated in "
+        "%select{the protocol's|the type's}2 module %3",
+        (Type, DeclName, bool, Identifier))
+NOTE(redundant_conformance_witness_ignored,none,
+     "%0 %1 will not be used to satisfy the conformance to %2",
+     (DescriptiveDeclKind, DeclName, DeclName))
 
 // "Near matches"
 WARNING(optional_req_near_match,none,
@@ -3604,12 +3615,14 @@ WARNING(debug_long_closure_body, none,
 ERROR(empty_switch_stmt,none,
       "'switch' statement body must have at least one 'case' or 'default' "
       "block; do you want to add a default case?",())
-ERROR(non_exhaustive_switch,none,
-      "%select{switch must be exhaustive, consider adding |do you want to add }0"
-      "%select{missing cases|a default clause}1"
-      "%select{:|?}0 %2", (bool, bool, StringRef))
+ERROR(non_exhaustive_switch,none, "switch must be exhaustive", ())
+NOTE(missing_several_cases,none,
+     "do you want to add "
+     "%select{missing cases|a default clause}0"
+     "?", (bool))
+
 NOTE(missing_particular_case,none,
-     "missing case: '%0'", (StringRef))
+     "add missing case: '%0'", (StringRef))
 WARNING(redundant_particular_case,none,
         "case is already handled by previous patterns; consider removing it",())
 

include/swift/AST/Expr.h

@@ -4558,12 +4558,21 @@ class ObjCSelectorExpr : public Expr {
 /// #keyPath(Person.friends.firstName)
 /// \endcode
 class KeyPathExpr : public Expr {
-  SourceLoc KeywordLoc;
+  SourceLoc StartLoc;
   SourceLoc LParenLoc;
-  SourceLoc RParenLoc;
-  TypeRepr *RootType;
+  SourceLoc EndLoc;
   Expr *ObjCStringLiteralExpr = nullptr;
 
+  // The parsed root of a Swift keypath (the section before an unusual dot, like
+  // Foo.Bar in \Foo.Bar.?.baz).
+  Expr *ParsedRoot = nullptr;
+  // The parsed path of a Swift keypath (the section after an unusual dot, like
+  // ?.baz in \Foo.Bar.?.baz).
+  Expr *ParsedPath = nullptr;
+
+  // The processed/resolved type, like Foo.Bar in \Foo.Bar.?.baz.
+  TypeRepr *RootType = nullptr;
+
 public:
   /// A single stored component, which will be one of:
   /// - an unresolved DeclName, which has to be type-checked
@@ -4772,17 +4781,23 @@ class KeyPathExpr : public Expr {
   /// Create a new #keyPath expression.
   KeyPathExpr(ASTContext &C,
               SourceLoc keywordLoc, SourceLoc lParenLoc,
-              TypeRepr *root,
               ArrayRef<Component> components,
               SourceLoc rParenLoc,
-              bool isObjC,
               bool isImplicit = false);
 
-  SourceLoc getLoc() const { return KeywordLoc; }
-  SourceRange getSourceRange() const {
-    return SourceRange(KeywordLoc, RParenLoc);
+  KeyPathExpr(SourceLoc backslashLoc, Expr *parsedRoot, Expr *parsedPath,
+              bool isImplicit = false)
+      : Expr(ExprKind::KeyPath, isImplicit), StartLoc(backslashLoc),
+        EndLoc(parsedPath ? parsedPath->getEndLoc() : parsedRoot->getEndLoc()),
+        ParsedRoot(parsedRoot), ParsedPath(parsedPath) {
+    assert((parsedRoot || parsedPath) &&
+           "keypath must have either root or path");
+    KeyPathExprBits.IsObjC = false;
   }
 
+  SourceLoc getLoc() const { return StartLoc; }
+  SourceRange getSourceRange() const { return SourceRange(StartLoc, EndLoc); }
+
   /// Get the components array.
   ArrayRef<Component> getComponents() const {
     return Components;
@@ -4807,11 +4822,34 @@ class KeyPathExpr : public Expr {
   void setObjCStringLiteralExpr(Expr *expr) {
     ObjCStringLiteralExpr = expr;
   }
-
+
+  Expr *getParsedRoot() const {
+    assert(!isObjC() && "cannot get parsed root of ObjC keypath");
+    return ParsedRoot;
+  }
+  void setParsedRoot(Expr *root) {
+    assert(!isObjC() && "cannot get parsed root of ObjC keypath");
+    ParsedRoot = root;
+  }
+
+  Expr *getParsedPath() const {
+    assert(!isObjC() && "cannot get parsed path of ObjC keypath");
+    return ParsedPath;
+  }
+  void setParsedPath(Expr *path) {
+    assert(!isObjC() && "cannot set parsed path of ObjC keypath");
+    ParsedPath = path;
+  }
+
   TypeRepr *getRootType() const {
+    assert(!isObjC() && "cannot get root type of ObjC keypath");
     return RootType;
   }
-
+  void setRootType(TypeRepr *rootType) {
+    assert(!isObjC() && "cannot set root type of ObjC keypath");
+    RootType = rootType;
+  }
+
   /// True if this is an ObjC key path expression.
   bool isObjC() const { return KeyPathExprBits.IsObjC; }
 
@@ -4820,6 +4858,22 @@ class KeyPathExpr : public Expr {
   }
 };
 
+/// Represents the unusual behaviour of a . in a \ keypath expression, such as
+/// \.[0] and \Foo.?.
+class KeyPathDotExpr : public Expr {
+  SourceLoc DotLoc;
+
+public:
+  KeyPathDotExpr(SourceLoc dotLoc)
+      : Expr(ExprKind::KeyPathDot, /*isImplicit=*/true), DotLoc(dotLoc) {}
+
+  SourceLoc getLoc() const { return DotLoc; }
+  SourceRange getSourceRange() const { return SourceRange(DotLoc, DotLoc); }
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::KeyPathDot;
+  }
+};
 
 inline bool Expr::isInfixOperator() const {
   return isa<BinaryExpr>(this) || isa<IfExpr>(this) ||

include/swift/AST/ExprNodes.def

@@ -168,6 +168,7 @@ UNCHECKED_EXPR(UnresolvedPattern, Expr)
 EXPR(EditorPlaceholder, Expr)
 EXPR(ObjCSelector, Expr)
 EXPR(KeyPath, Expr)
+UNCHECKED_EXPR(KeyPathDot, Expr)
 
 #undef EXPR_RANGE
 #undef LITERAL_EXPR

include/swift/AST/Type.h

@@ -72,6 +72,15 @@ struct QueryTypeSubstitutionMap {
   Type operator()(SubstitutableType *type) const;
 };
 
+/// A function object suitable for use as a \c TypeSubstitutionFn that
+/// queries an underlying \c TypeSubstitutionMap, or returns the original type
+/// if no match was found.
+struct QueryTypeSubstitutionMapOrIdentity {
+  const TypeSubstitutionMap &substitutions;
+
+  Type operator()(SubstitutableType *type) const;
+};
+
 /// A function object suitable for use as a \c TypeSubstitutionFn that
 /// queries an underlying \c SubstitutionMap.
 struct QuerySubstitutionMap {

include/swift/Basic/LangOptions.h

@@ -46,6 +46,19 @@ namespace swift {
   };
   enum { NumPlatformConditionKind = 4 };
 
+  /// Describes which Swift 3 Objective-C inference warnings should be
+  /// emitted.
+  enum class Swift3ObjCInferenceWarnings {
+    /// No warnings; this is the default.
+    None,
+    /// "Minimal" warnings driven by uses of declarations that make use of
+    /// the Objective-C entry point directly.
+    Minimal,
+    /// "Complete" warnings that add "@objc" for every entry point that
+    /// Swift 3 would have inferred as "@objc" but Swift 4 will not.
+    Complete,
+  };
+
   /// \brief A collection of options that affect the language dialect and
   /// provide compiler debugging facilities.
   class LangOptions {
@@ -212,7 +225,8 @@ namespace swift {
 
     /// Warn about cases where Swift 3 would infer @objc but later versions
     /// of Swift do not.
-    bool WarnSwift3ObjCInference = false;
+    Swift3ObjCInferenceWarnings WarnSwift3ObjCInference =
+      Swift3ObjCInferenceWarnings::None;
 
     /// Enable keypaths.
     bool EnableExperimentalKeyPaths = false;

include/swift/Frontend/Frontend.h

@@ -426,6 +426,10 @@ class CompilerInstance {
   /// Parses the input file but does no type-checking or module imports.
   /// Note that this only supports parsing an invocation with a single file.
   void performParseOnly();
+
+  /// Frees up the ASTContext and SILModule objects that this instance is
+  /// holding on.
+  void freeContextAndSIL();
 };
 
 } // namespace swift

include/swift/IDE/APIDigesterData.h

@@ -55,6 +55,7 @@ struct APIDiffItem {
   virtual APIDiffItemKind getKind() const = 0;
   virtual StringRef getKey() const = 0;
   virtual ~APIDiffItem() = default;
+  bool operator==(const APIDiffItem &Other) const;
 };
 
 // CommonDiffItem describes how an element in SDK evolves in a way that migrator can

include/swift/Migrator/EditorAdapter.h

@@ -108,6 +108,7 @@ class EditorAdapter {
   bool remove(SourceLoc TokenLoc);
   bool remove(SourceRange TokenRange);
   bool replace(SourceRange TokenRange, StringRef Text);
+  bool replaceToken(SourceLoc TokenLoc, StringRef Text);
   bool replaceWithInner(SourceRange TokenRange, SourceRange TokenInnerRange);
 
   /// Return the batched edits encountered so far.