Merge branch 'main' into v-gsampath/hdfs

Author: Gnanasundaramsampath-sys

.vscode/cspell.json

@@ -2209,6 +2209,11 @@
       "words": ["envml", "paginators"]
     },
     {
+      "filename": "sdk/planetarycomputer/azure-planetarycomputer/**",
+      "words": ["topo", "haline", "Aproperty", "pygen"]
+    },
+    {
+      "filename": "sdk/agentserver/azure-ai-agentserver-githubcopilot/**",
       "filename": "sdk/agentserver/azure-ai-agentserver-ghcopilot/**",
       "words": ["RAPI", "BYOK", "byok", "NCUS", "ncusacr", "fstring", "ename", "valeriepham", "coreai", "Vnext", "PYTHONIOENCODING"]
     }

eng/common/scripts/Helpers/DevOps-WorkItem-Helpers.ps1

@@ -1205,6 +1205,7 @@ function Get-ReleasePlan-Link($releasePlanWorkItemId)
   $fields += "System.Title"
   $fields += "Custom.ReleasePlanLink"
   $fields += "Custom.ReleasePlanSubmittedby"
+  $fields += "Custom.ReleasePlanID"
 
   $fieldList = ($fields | ForEach-Object { "[$_]"}) -join ", "
   $query = "SELECT ${fieldList} FROM WorkItems WHERE [System.Id] = $releasePlanWorkItemId"

scripts/breaking_changes_checker/breaking_changes_allowlist.py

@@ -37,6 +37,7 @@
         ("RemovedOrRenamedPositionalParam", "*", "*", "as_dict", "key_transformer"),
         ("RemovedOrRenamedPositionalParam", "*", "*", "as_dict"),
         ("RemovedFunctionKwargs", "*", "*", "as_dict"),
+        ("ChangedFunctionReturnType", "*", "*", "as_dict"),
         # operation group can't be instantiated independently so don't need check for it
         ("RemovedOrRenamedPositionalParam", "*", "*", "__init__", "client"),
         ("RemovedOrRenamedPositionalParam", "*", "*", "__init__", "config"),

scripts/breaking_changes_checker/checkers/changed_function_return_type_checker.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python
+
+# --------------------------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# --------------------------------------------------------------------------------------------
+import os
+import re
+import sys
+
+sys.path.append(os.path.abspath("../../scripts/breaking_changes_checker"))
+from _models import CheckerType
+import jsondiff
+
+
+# Pairs of return-type names that are semantically equivalent in the Azure SDK
+# and should not be flagged as a breaking change. The concrete paged types
+# (`ItemPaged` / `AsyncItemPaged`) implement the corresponding abstract
+# iterable protocols (`Iterable` / `AsyncIterable`), so a switch between them
+# is a no-op for callers. The `typing` generic aliases (`Dict`, `List`, ...)
+# are equivalent to the PEP 585 builtin generics (`dict`, `list`, ...).
+_EQUIVALENT_RETURN_TYPES = (
+    ("ItemPaged", "Iterable"),
+    ("AsyncItemPaged", "AsyncIterable"),
+    ("Dict", "dict"),
+    ("List", "list"),
+    ("Tuple", "tuple"),
+    ("Set", "set"),
+    ("FrozenSet", "frozenset"),
+    ("Type", "type"),
+)
+
+
+def _normalize_return_type(value):
+    """Normalize known-equivalent return type spellings so the comparison
+    treats e.g. ``AsyncIterable[X]`` and ``AsyncItemPaged[X]`` as identical.
+    Module-qualified names (e.g. ``azure.core.paging.ItemPaged``) are also
+    matched. Returns ``value`` unchanged if it is not a string.
+    """
+    if not isinstance(value, str):
+        return value
+    normalized = value
+    for concrete, abstract in _EQUIVALENT_RETURN_TYPES:
+        # Collapse both the concrete and abstract spellings (with any
+        # module-path prefix, e.g. ``azure.core.paging.ItemPaged`` or
+        # ``typing.Iterable``) down to the bare abstract name. This way
+        # ``typing.AsyncIterable[X]`` and
+        # ``azure.core.async_paging.AsyncItemPaged[X]`` both normalize to
+        # ``AsyncIterable[X]``.
+        normalized = re.sub(
+            rf"(?:\w+\.)*(?:{concrete}|{abstract})\b",
+            abstract,
+            normalized,
+        )
+    return normalized
+
+
+class ChangedFunctionReturnTypeChecker:
+    """Detect a change to a function/method return type annotation.
+
+    Resolves https://github.com/Azure/azure-sdk-for-python/issues/46489 - the
+    breaking-changes detector previously did not capture or compare return type
+    annotations for normal (non-`@overload`) callables, so a regression like
+    ``LROPoller[Fleet]`` -> ``LROPoller[None]`` was undetected.
+
+    The checker is invoked twice per module by the dispatcher in
+    :class:`BreakingChangesTracker`: once with the class methods of every class
+    (``class_name`` provided) and once with the module-level functions
+    (``class_name`` is ``None``).
+
+    To stay backwards compatible with reports generated by older versions of
+    the tool that did not record ``return_type``, the checker silently skips a
+    function whose stable snapshot does not include the field.
+    """
+
+    node_type = CheckerType.FUNCTION_OR_METHOD
+    name = "ChangedFunctionReturnType"
+    is_breaking = True
+    message = {
+        "method": "Method `{}.{}` changed return type from `{}` to `{}`",
+        "function": "Function `{}` changed return type from `{}` to `{}`",
+    }
+
+    def run_check(self, diff, stable_nodes, current_nodes, **kwargs):
+        module_name = kwargs.get("module_name")
+        class_name = kwargs.get("class_name")
+        bc_list = []
+
+        # New module: nothing to compare against.
+        if module_name not in stable_nodes:
+            return bc_list
+        if class_name is not None and class_name not in stable_nodes[module_name].get("class_nodes", {}):
+            return bc_list
+
+        for function_name, function_components in diff.items():
+            # Skip removed/renamed entries; those are handled by other checkers.
+            if isinstance(function_name, jsondiff.Symbol):
+                continue
+            # `function_components` from the jsondiff view may not contain the
+            # full record. Resolve current/stable values by lookup so we always
+            # compare the authoritative snapshots, mirroring the pattern in
+            # `RemovedMethodOverloadChecker`.
+            stable_fn = self._lookup(stable_nodes, module_name, class_name, function_name)
+            current_fn = self._lookup(current_nodes, module_name, class_name, function_name)
+            if not isinstance(stable_fn, dict) or not isinstance(current_fn, dict):
+                continue
+            # Legacy stable reports may not have captured `return_type`.
+            # Treat missing-in-stable as "unknown" rather than as a breaking
+            # change to avoid noisy false positives during rollout.
+            if "return_type" not in stable_fn:
+                continue
+            stable_value = stable_fn.get("return_type")
+            current_value = current_fn.get("return_type")
+            if stable_value is None or stable_value == current_value:
+                continue
+            # Treat known-equivalent paged return types as unchanged
+            # (e.g. `AsyncIterable[X]` <-> `AsyncItemPaged[X]`).
+            if _normalize_return_type(stable_value) == _normalize_return_type(current_value):
+                continue
+            if class_name:
+                bc_list.append(
+                    (
+                        self.message["method"], self.name, module_name, class_name, function_name,
+                        stable_value, current_value,
+                    )
+                )
+            else:
+                bc_list.append(
+                    (
+                        self.message["function"], self.name, module_name, function_name,
+                        stable_value, current_value,
+                    )
+                )
+        return bc_list
+
+    @staticmethod
+    def _lookup(nodes, module_name, class_name, function_name):
+        module = nodes.get(module_name, {})
+        if class_name:
+            return (
+                module.get("class_nodes", {})
+                .get(class_name, {})
+                .get("methods", {})
+                .get(function_name)
+            )
+        return module.get("function_nodes", {}).get(function_name)

scripts/breaking_changes_checker/detect_breaking_changes.py

@@ -239,9 +239,41 @@ def get_properties(cls: Type) -> Dict:
     return attribute_names
 
 
+def _is_overload_decorator(dec: ast.expr) -> bool:
+    """Return True if the AST decorator node is `@overload` or `@typing.overload`."""
+    # Bare `@overload`
+    if isinstance(dec, ast.Name) and dec.id == "overload":
+        return True
+    # Qualified `@typing.overload` (or any `pkg.overload`)
+    if isinstance(dec, ast.Attribute) and dec.attr == "overload":
+        return True
+    return False
+
+
+def _find_function_def_in_body(
+    body, target_name: str
+) -> Optional[Union[ast.FunctionDef, ast.AsyncFunctionDef]]:
+    """Return the first non-overload (Async)FunctionDef in ``body`` matching ``target_name``.
+
+    Only scans direct children of ``body`` -- does NOT recurse -- so a method
+    lookup is scoped to the owning class body and a module-level function
+    lookup is scoped to the module's top level.
+    """
+    for node in body:
+        if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        if node.name != target_name:
+            continue
+        # Skip @overload stubs - handled separately by `get_overload_data`.
+        if any(_is_overload_decorator(dec) for dec in node.decorator_list):
+            continue
+        return node
+    return None
+
+
 def create_function_report(f: Callable, is_async: bool = False) -> Dict:
     function = inspect.signature(f)
-    func_obj = {"parameters": {}, "is_async": is_async}
+    func_obj = {"parameters": {}, "is_async": is_async, "return_type": None}
 
     for par in function.parameters.values():
         default_value = get_parameter_default(par)
@@ -262,6 +294,54 @@ def create_function_report(f: Callable, is_async: bool = False) -> Dict:
         param[par.name]["param_type"] = param_type
         func_obj["parameters"].update(param)
 
+    # Capture the return type annotation by inspecting the source AST. We use
+    # the AST rather than `inspect.signature(f).return_annotation` because the
+    # latter resolves to live type objects whose `str()` representation differs
+    # from the source-level annotation (e.g. fully qualified module paths,
+    # generic alias quirks). Using AST keeps the captured value consistent with
+    # how parameter types are recorded for overloads via `get_parameter_type`.
+    #
+    # Scope the lookup so we don't pick up an unrelated same-named function or
+    # a method on a different class in the same module:
+    #   - For methods (qualname like "Cls.method"), search only the owning
+    #     ClassDef's direct body.
+    #   - For module-level functions, search only the module's top-level body.
+    try:
+        lookup_target = f
+        try:
+            lookup_target = inspect.unwrap(f)
+        except (AttributeError, ValueError, TypeError):
+            # Fall back to the original callable when unwrap is not possible.
+            lookup_target = f
+
+        source_path = inspect.getsourcefile(lookup_target)
+        target_name = getattr(lookup_target, "__name__", None)
+        qualname = getattr(lookup_target, "__qualname__", target_name) or ""
+        if source_path and target_name:
+            module_ast = _get_parsed_module(source_path)
+            target_node = None
+            # Heuristic: a qualname of the form "Owner.method" with no
+            # "<locals>" segment indicates a method bound to a class named
+            # by the first qualname component.
+            qualname_parts = qualname.split(".")
+            if (
+                len(qualname_parts) >= 2
+                and qualname_parts[-1] == target_name
+                and "<locals>" not in qualname_parts
+            ):
+                owner_class = qualname_parts[-2]
+                cls_node = _find_class_node(module_ast, owner_class)
+                if cls_node is not None:
+                    target_node = _find_function_def_in_body(cls_node.body, target_name)
+            if target_node is None:
+                # Module-level function (or fallback if class lookup failed).
+                target_node = _find_function_def_in_body(module_ast.body, target_name)
+            if target_node is not None and target_node.returns is not None:
+                func_obj["return_type"] = get_parameter_type(target_node.returns)
+    except (TypeError, OSError, SyntaxError) as exc:
+        # Built-ins, C-implemented functions, or unreadable source files.
+        _LOGGER.debug("Unable to capture return type for %r: %s", f, exc)
+
     return func_obj
 
 
@@ -276,6 +356,8 @@ def get_parameter_default_ast(default):
 
 
 def get_parameter_type(annotation) -> str:
+    if annotation is None:
+        return None
     if isinstance(annotation, ast.Name):
         return annotation.id
     if isinstance(annotation, ast.Attribute):
@@ -291,7 +373,26 @@ def get_parameter_type(annotation) -> str:
         return f"{get_parameter_type(annotation.value)}[{get_parameter_type(annotation.slice)}]"
     if isinstance(annotation, ast.Tuple):
         return ", ".join([get_parameter_type(el) for el in annotation.elts])
-    return annotation
+    # PEP 604 union syntax (e.g. ``int | None``) parses as ``ast.BinOp`` with
+    # ``ast.BitOr``. Represent it as a ``Union[...]`` string so the captured
+    # value remains JSON-serializable.
+    if isinstance(annotation, ast.BinOp) and isinstance(annotation.op, ast.BitOr):
+        parts = []
+        def _flatten(node):
+            if isinstance(node, ast.BinOp) and isinstance(node.op, ast.BitOr):
+                _flatten(node.left)
+                _flatten(node.right)
+            else:
+                parts.append(get_parameter_type(node))
+        _flatten(annotation)
+        return f"Union[{', '.join(str(p) for p in parts)}]"
+    # Fall back to a source-level string representation so we never return a
+    # raw AST node (which would not be JSON-serializable when the report is
+    # written via ``json.dump``).
+    try:
+        return ast.unparse(annotation)
+    except Exception:  # pylint: disable=broad-except
+        return str(annotation)
 
 
 def create_parameters(args: ast.arg) -> Dict:
@@ -391,11 +492,14 @@ def get_overload_data(node: ast.ClassDef, cls_methods: Dict) -> None:
             is_async = True
         # method_overloads.update({func.name: {"parameters": {}, "is_async": False, "return_type": None}})
         for decorator in func.decorator_list:
-            if hasattr(decorator, "id") and decorator.id == "overload":
+            if _is_overload_decorator(decorator):
+                overload_return_type = None
+                if func.returns is not None:
+                    overload_return_type = get_parameter_type(func.returns)
                 overload_report = {
                     "parameters": create_parameters(func.args),
                     "is_async": is_async,
-                    "return_type": None,
+                    "return_type": overload_return_type,
                 }
                 cls_methods[func.name]["overloads"].append(overload_report)
 

scripts/breaking_changes_checker/supported_checkers.py

@@ -7,11 +7,13 @@
 
 from checkers.removed_method_overloads_checker import RemovedMethodOverloadChecker
 from checkers.added_method_overloads_checker import AddedMethodOverloadChecker
+from checkers.changed_function_return_type_checker import ChangedFunctionReturnTypeChecker
 from checkers.unflattened_models_checker import UnflattenedModelsChecker
 
 CHECKERS = [
     RemovedMethodOverloadChecker(),
     AddedMethodOverloadChecker(),
+    ChangedFunctionReturnTypeChecker(),
 ]
 
 POST_PROCESSING_CHECKERS = [

scripts/breaking_changes_checker/tests/examples/return_type_capture/__init__.py

@@ -0,0 +1,36 @@
+# --------------------------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# --------------------------------------------------------------------------------------------
+"""Fixture exercising return-type capture in `create_function_report`.
+
+Includes two classes that share a method name (``list``) and a module-level
+function that also shares the same name. This pins down the regression where
+the previous AST walk would match the first same-named function in the file,
+regardless of class scope.
+
+It also covers ``@typing.overload``-decorated stubs to ensure the AST walk
+skips them and reads the implementation's return annotation.
+"""
+import typing
+
+
+class FooOperations:
+    def list(self) -> str:  # noqa: A003
+        return ""
+
+    @typing.overload
+    def fetch(self, value: int) -> int: ...
+    @typing.overload
+    def fetch(self, value: str) -> str: ...
+    def fetch(self, value) -> "typing.Union[int, str]":
+        return value
+
+
+class BarOperations:
+    def list(self) -> bytes:  # noqa: A003
+        return b""
+
+
+def list() -> int:  # noqa: A001
+    return 0