Cant find SwapChainDescriptor and SwapChain

[tyoc213]

Hi there, following https://sotrh.github.io/learn-wgpu/ the swap chain example says

(it seems it existed up to 0.9.0 https://docs.rs/wgpu/0.9.0/wgpu/struct.SwapChain.html)

error[E0412]: cannot find type `SwapChainDescriptor` in crate `wgpu`
error[E0412]: cannot find type `SwapChain` in crate `wgpu`
error[E0422]: cannot find struct, variant or union type `SwapChainDescriptor` in crate `wgpu`

use winit::{event::WindowEvent, window::Window};

struct State {
    surface: wgpu::Surface,
    device: wgpu::Device,
    queue: wgpu::Queue,
    sc_desc:  wgpu::SwapChainDescriptor,
    swap_chain: wgpu::SwapChain,
    size: winit::dpi::PhysicalSize<u32>,
}

impl State {
    // Creating some of the wgpu types requires async code
    async fn new(window: &Window) -> Self {
        let size = window.inner_size();

        // the instance is a handle toour GPU
        // backendBig:: PRIMARY => Vulkan+ Metal + DS12 + Browser WebGPU
        // TODO: can do instance.enumerate_adapters
        let instance = wgpu::Instance::new(wgpu::Backends::PRIMARY);
        let surface = unsafe {instance.create_surface(window)};
        let adapter = instance.request_adapter(
            &wgpu::RequestAdapterOptions {
                power_preference: wgpu::PowerPreference::default(),
                compatible_surface: Some(&surface),
            },
        ).await.unwrap();

        let (device, queue) = adapter.request_device(
            &wgpu::DeviceDescriptor {
                features: wgpu::Features::empty(),
                limits: wgpu::Limits::default(),
                label: None,
            },
            None,
        ).await.unwrap();

        let sc_desc = wgpu::SwapChainDescriptor {
            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
            format: adapter.get_swap_chain_preferred_format(&surface).unwrap(),
            width: size.width,
            height: size.height,
            present_mode: wgpu::PresentMode::Fifo,
        };
        let swap_chain = device.create_swap_chain(&surface, &sc_desc);

        Self {
            surface,
            device,
            queue,
            sc_desc,
            swap_chain,
            size,
        }

    }

    fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
        todo!()
    }

    fn input(&mut self, event: &WindowEvent) -> bool {
        todo!()
    }

    fn update(&mut self) {
        todo!()
    }

    fn render(&mut self) -> Result<(), wgpu::SwapChainError>{
        todo!()
    }
}

fn main(){}

Cargo.toml looks like

[package]
name = "learnwebgpu"
version = "0.1.0"
edition = "2018"
resolver = "2"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
image = "0.23.14"
winit = "0.25.0"
cgmath = "0.18.0"
env_logger = "0.9"
log = "0.4.14"
wgpu = "0.10.1"
pollster = "0.2.4"

[cwfitzgerald]

The swapchain has been merged into the surface. Where you once made a new swapchain, you now call surface.configure() and your acquire_next_frame calls also go on the surface.

[kvark]

If you are following a tutorial, make sure to set the same wgpu version dependency as the tutorial is using.