1 files changed, 79 insertions, 33 deletions

diff --git a/lib/Sema/SemaAttr.cpp b/lib/Sema/SemaAttr.cpp
index 1a8a000753062..2bc1b769f77a1 100644
--- a/lib/Sema/SemaAttr.cpp
+++ b/lib/Sema/SemaAttr.cpp
@@ -405,7 +405,7 @@ void Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation,
     Diag(PragmaLocation, diag::warn_pragma_pop_failed) << PragmaName
         << "stack empty";
   if (SegmentName &&
-      !checkSectionName(SegmentName->getLocStart(), SegmentName->getString()))
+      !checkSectionName(SegmentName->getBeginLoc(), SegmentName->getString()))
     return;
   Stack->Act(PragmaLocation, Action, StackSlotLabel, SegmentName);
 }
@@ -520,9 +520,9 @@ attrMatcherRuleListToString(ArrayRef<attr::SubjectMatchRule> Rules) {
 
 } // end anonymous namespace
 
-void Sema::ActOnPragmaAttributePush(ParsedAttr &Attribute,
-                                    SourceLocation PragmaLoc,
-                                    attr::ParsedSubjectMatchRuleSet Rules) {
+void Sema::ActOnPragmaAttributeAttribute(
+    ParsedAttr &Attribute, SourceLocation PragmaLoc,
+    attr::ParsedSubjectMatchRuleSet Rules) {
   SmallVector<attr::SubjectMatchRule, 4> SubjectMatchRules;
   // Gather the subject match rules that are supported by the attribute.
   SmallVector<std::pair<attr::SubjectMatchRule, bool>, 4>
@@ -622,54 +622,88 @@ void Sema::ActOnPragmaAttributePush(ParsedAttr &Attribute,
     Diagnostic << attrMatcherRuleListToString(ExtraRules);
   }
 
-  PragmaAttributeStack.push_back(
+  if (PragmaAttributeStack.empty()) {
+    Diag(PragmaLoc, diag::err_pragma_attr_attr_no_push);
+    return;
+  }
+
+  PragmaAttributeStack.back().Entries.push_back(
       {PragmaLoc, &Attribute, std::move(SubjectMatchRules), /*IsUsed=*/false});
 }
 
-void Sema::ActOnPragmaAttributePop(SourceLocation PragmaLoc) {
+void Sema::ActOnPragmaAttributeEmptyPush(SourceLocation PragmaLoc,
+                                         const IdentifierInfo *Namespace) {
+  PragmaAttributeStack.emplace_back();
+  PragmaAttributeStack.back().Loc = PragmaLoc;
+  PragmaAttributeStack.back().Namespace = Namespace;
+}
+
+void Sema::ActOnPragmaAttributePop(SourceLocation PragmaLoc,
+                                   const IdentifierInfo *Namespace) {
   if (PragmaAttributeStack.empty()) {
-    Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch);
+    Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;
     return;
   }
-  const PragmaAttributeEntry &Entry = PragmaAttributeStack.back();
-  if (!Entry.IsUsed) {
-    assert(Entry.Attribute && "Expected an attribute");
-    Diag(Entry.Attribute->getLoc(), diag::warn_pragma_attribute_unused)
-        << Entry.Attribute->getName();
-    Diag(PragmaLoc, diag::note_pragma_attribute_region_ends_here);
+
+  // Dig back through the stack trying to find the most recently pushed group
+  // that in Namespace. Note that this works fine if no namespace is present,
+  // think of push/pops without namespaces as having an implicit "nullptr"
+  // namespace.
+  for (size_t Index = PragmaAttributeStack.size(); Index;) {
+    --Index;
+    if (PragmaAttributeStack[Index].Namespace == Namespace) {
+      for (const PragmaAttributeEntry &Entry :
+           PragmaAttributeStack[Index].Entries) {
+        if (!Entry.IsUsed) {
+          assert(Entry.Attribute && "Expected an attribute");
+          Diag(Entry.Attribute->getLoc(), diag::warn_pragma_attribute_unused)
+              << *Entry.Attribute;
+          Diag(PragmaLoc, diag::note_pragma_attribute_region_ends_here);
+        }
+      }
+      PragmaAttributeStack.erase(PragmaAttributeStack.begin() + Index);
+      return;
+    }
   }
-  PragmaAttributeStack.pop_back();
+
+  if (Namespace)
+    Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch)
+        << 0 << Namespace->getName();
+  else
+    Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;
 }
 
 void Sema::AddPragmaAttributes(Scope *S, Decl *D) {
   if (PragmaAttributeStack.empty())
     return;
-  for (auto &Entry : PragmaAttributeStack) {
-    ParsedAttr *Attribute = Entry.Attribute;
-    assert(Attribute && "Expected an attribute");
-
-    // Ensure that the attribute can be applied to the given declaration.
-    bool Applies = false;
-    for (const auto &Rule : Entry.MatchRules) {
-      if (Attribute->appliesToDecl(D, Rule)) {
-        Applies = true;
-        break;
+  for (auto &Group : PragmaAttributeStack) {
+    for (auto &Entry : Group.Entries) {
+      ParsedAttr *Attribute = Entry.Attribute;
+      assert(Attribute && "Expected an attribute");
+
+      // Ensure that the attribute can be applied to the given declaration.
+      bool Applies = false;
+      for (const auto &Rule : Entry.MatchRules) {
+        if (Attribute->appliesToDecl(D, Rule)) {
+          Applies = true;
+          break;
+        }
       }
+      if (!Applies)
+        continue;
+      Entry.IsUsed = true;
+      PragmaAttributeCurrentTargetDecl = D;
+      ParsedAttributesView Attrs;
+      Attrs.addAtEnd(Attribute);
+      ProcessDeclAttributeList(S, D, Attrs);
+      PragmaAttributeCurrentTargetDecl = nullptr;
     }
-    if (!Applies)
-      continue;
-    Entry.IsUsed = true;
-    PragmaAttributeCurrentTargetDecl = D;
-    ParsedAttributesView Attrs;
-    Attrs.addAtStart(Attribute);
-    ProcessDeclAttributeList(S, D, Attrs);
-    PragmaAttributeCurrentTargetDecl = nullptr;
   }
 }
 
 void Sema::PrintPragmaAttributeInstantiationPoint() {
   assert(PragmaAttributeCurrentTargetDecl && "Expected an active declaration");
-  Diags.Report(PragmaAttributeCurrentTargetDecl->getLocStart(),
+  Diags.Report(PragmaAttributeCurrentTargetDecl->getBeginLoc(),
                diag::note_pragma_attribute_applied_decl_here);
 }
 
@@ -773,6 +807,18 @@ void Sema::ActOnPragmaFPContract(LangOptions::FPContractModeKind FPC) {
   }
 }
 
+void Sema::ActOnPragmaFEnvAccess(LangOptions::FEnvAccessModeKind FPC) {
+  switch (FPC) {
+  case LangOptions::FEA_On:
+    FPFeatures.setAllowFEnvAccess();
+    break;
+  case LangOptions::FEA_Off:
+    FPFeatures.setDisallowFEnvAccess();
+    break;
+  }
+}
+
+
 void Sema::PushNamespaceVisibilityAttr(const VisibilityAttr *Attr,
                                        SourceLocation Loc) {
   // Visibility calculations will consider the namespace's visibility.